Rename all filter functions to follow the pattern starpu_DATATYPE_filter_FILTERTYPE.

The script tools/dev/rename_filter.sh is provided to rename existing
applications using filters.

ChangeLog

@@ -138,6 +138,10 @@ Changes:
     instead.
   * StarPU can now use poti to generate paje traces.
   * Rename scheduling policy "parallel greedy" to "parallel eager"
+  * Rename all filter functions to follow the pattern
+    starpu_DATATYPE_filter_FILTERTYPE. The script
+    tools/dev/rename_filter.sh is provided to rename your existing
+    applications using filters.
 
 Small changes:
   * STARPU_NCPU should now be used instead of STARPU_NCPUS. STARPU_NCPUS is

doc/chapters/advanced-examples.texi

@@ -234,7 +234,7 @@ starpu_vector_data_register(&handle, 0, (uintptr_t)vector,
 /* Partition the vector in PARTS sub-vectors */
 starpu_data_filter f =
 @{
-    .filter_func = starpu_block_filter_func_vector,
+    .filter_func = starpu_vector_filter_block,
     .nchildren = PARTS
 @};
 starpu_data_partition(handle, &f);

doc/chapters/basic-api.texi

@@ -1280,7 +1280,7 @@ subdata according to the filter @var{f}, as shown in the following example:
 @cartouche
 @smallexample
 struct starpu_data_filter f = @{
-    .filter_func = starpu_block_filter_func,
+    .filter_func = starpu_matrix_filter_block,
     .nchildren = nslicesx,
     .get_nchildren = NULL,
     .get_child_ops = NULL
@@ -1359,13 +1359,13 @@ list can be found in @code{starpu_data_filters.h} .
 @node Partitioning Vector Data
 @subsubsection Partitioning Vector Data
 
-@deftypefun void starpu_block_filter_func_vector (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_vector_filter_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 Return in @code{*@var{child_interface}} the @var{id}th element of the
 vector represented by @var{father_interface} once partitioned in
 @var{nparts} chunks of equal size.
 @end deftypefun
 
-@deftypefun void starpu_block_shadow_filter_func_vector (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_vector_filter_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 Return in @code{*@var{child_interface}} the @var{id}th element of the
 vector represented by @var{father_interface} once partitioned in
 @var{nparts} chunks of equal size with a shadow border @code{filter_arg_ptr}, thus getting a vector of size (n-2*shadow)/nparts+2*shadow
@@ -1378,7 +1378,7 @@ enforced for the shadowed parts.
 A usage example is available in examples/filters/shadow.c
 @end deftypefun
 
-@deftypefun void starpu_vector_list_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_vector_filter_list (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 Return in @code{*@var{child_interface}} the @var{id}th element of the
 vector represented by @var{father_interface} once partitioned into
 @var{nparts} chunks according to the @code{filter_arg_ptr} field of
@@ -1389,7 +1389,7 @@ The @code{filter_arg_ptr} field must point to an array of @var{nparts}
 in each chunk of the partition.
 @end deftypefun
 
-@deftypefun void starpu_vector_divide_in_2_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_vector_filter_divide_in_2 (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 Return in @code{*@var{child_interface}} the @var{id}th element of the
 vector represented by @var{father_interface} once partitioned in two
 chunks of equal size, ignoring @var{nparts}.  Thus, @var{id} must be
@@ -1400,13 +1400,13 @@ chunks of equal size, ignoring @var{nparts}.  Thus, @var{id} must be
 @node Partitioning Matrix Data
 @subsubsection Partitioning Matrix Data
 
-@deftypefun void starpu_block_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_matrix_filter_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix along the x dimension, thus getting (x/nparts,y)
 matrices. If nparts does not divide x, the last submatrix contains the
 remainder.
 @end deftypefun
 
-@deftypefun void starpu_block_shadow_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_matrix_filter_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix along the x dimension, with a shadow border
 @code{filter_arg_ptr}, thus getting ((x-2*shadow)/nparts+2*shadow,y)
 matrices. If nparts does not divide x-2*shadow, the last submatrix contains the
@@ -1418,13 +1418,13 @@ enforced for the shadowed parts.
 A usage example is available in examples/filters/shadow2d.c
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_matrix_filter_vertical_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix along the y dimension, thus getting (x,y/nparts)
 matrices. If nparts does not divide y, the last submatrix contains the
 remainder.
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_shadow_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_matrix_filter_vertical_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix along the y dimension, with a shadow border
 @code{filter_arg_ptr}, thus getting (x,(y-2*shadow)/nparts+2*shadow)
 matrices. If nparts does not divide y-2*shadow, the last submatrix contains the
@@ -1441,13 +1441,13 @@ A usage example is available in examples/filters/shadow2d.c
 
 A usage example is available in examples/filters/shadow3d.c
 
-@deftypefun void starpu_block_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the X dimension, thus getting (x/nparts,y,z)
 3D matrices. If nparts does not divide x, the last submatrix contains the
 remainder.
 @end deftypefun
 
-@deftypefun void starpu_block_shadow_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the X dimension, with a shadow border
 @code{filter_arg_ptr}, thus getting ((x-2*shadow)/nparts+2*shadow,y,z) 3D
 matrices. If nparts does not divide x, the last submatrix contains the
@@ -1457,13 +1457,13 @@ IMPORTANT: This can only be used for read-only access, as no coherency is
 enforced for the shadowed parts.
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_vertical_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the Y dimension, thus getting (x,y/nparts,z)
 3D matrices. If nparts does not divide y, the last submatrix contains the
 remainder.
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_shadow_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_vertical_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the Y dimension, with a shadow border
 @code{filter_arg_ptr}, thus getting (x,(y-2*shadow)/nparts+2*shadow,z) 3D
 matrices. If nparts does not divide y, the last submatrix contains the
@@ -1473,13 +1473,13 @@ IMPORTANT: This can only be used for read-only access, as no coherency is
 enforced for the shadowed parts.
 @end deftypefun
 
-@deftypefun void starpu_depth_block_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_depth_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the Z dimension, thus getting (x,y,z/nparts)
 3D matrices. If nparts does not divide z, the last submatrix contains the
 remainder.
 @end deftypefun
 
-@deftypefun void starpu_depth_block_shadow_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_block_filter_depth_block_shadow (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the Z dimension, with a shadow border
 @code{filter_arg_ptr}, thus getting (x,y,(z-2*shadow)/nparts+2*shadow)
 3D matrices. If nparts does not divide z, the last submatrix contains the
@@ -1492,11 +1492,11 @@ enforced for the shadowed parts.
 @node Partitioning BCSR Data
 @subsubsection Partitioning BCSR Data
 
-@deftypefun void starpu_canonical_block_filter_bcsr (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_bcsr_filter_canonical_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a block-sparse matrix into dense matrices.
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_filter_func_csr (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
+@deftypefun void starpu_csr_filter_vertical_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a block-sparse matrix into vertical block-sparse matrices.
 @end deftypefun
 

examples/audio/starpu_audio_processing.c

@@ -418,7 +418,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = niter
 	};
 

examples/axpy/axpy.c

@@ -157,7 +157,7 @@ int main(int argc, char **argv)
 	/* Divide the vector into blocks */
 	struct starpu_data_filter block_filter =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = NBLOCKS
 	};
 

examples/basic_examples/mult.c

@@ -194,13 +194,13 @@ static void partition_mult_data(void)
 	 * name of the filters are a bit misleading */
 	struct starpu_data_filter vert =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nslicesx
 	};
 
 	struct starpu_data_filter horiz =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nslicesy
 	};
 

examples/cg/cg.c

@@ -197,10 +197,10 @@ static void partition_data(void)
 	 */
 
 	/* Partition into contiguous parts */
-	matrix_filter_1.filter_func = starpu_block_filter_func;
+	matrix_filter_1.filter_func = starpu_matrix_filter_block;
 	matrix_filter_1.nchildren = nblocks;
 	/* Partition into non-contiguous parts */
-	matrix_filter_2.filter_func = starpu_vertical_block_filter_func;
+	matrix_filter_2.filter_func = starpu_matrix_filter_vertical_block;
 	matrix_filter_2.nchildren = nblocks;
 
 	/* A is in FORTRAN ordering, starpu_data_get_sub_data(A_handle, 2, i,
@@ -211,7 +211,7 @@ static void partition_data(void)
 	 *	Partition the vectors
 	 */
 
-	vector_filter.filter_func = starpu_block_filter_func_vector;
+	vector_filter.filter_func = starpu_vector_filter_block;
 	vector_filter.nchildren = nblocks;
 
 	starpu_data_partition(b_handle, &vector_filter);

examples/cholesky/cholesky_grain_tag.c

@@ -195,13 +195,13 @@ static int cholesky_grain_rec(float *matA, unsigned size, unsigned ld, unsigned
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/cholesky/cholesky_implicit.c

@@ -182,13 +182,13 @@ static int cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/cholesky/cholesky_tag.c

@@ -285,13 +285,13 @@ static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/filters/fblock.c

@@ -120,7 +120,7 @@ int main(int argc, char **argv)
         /* Partition the block in PARTS sub-blocks */
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_block,
+		.filter_func = starpu_block_filter_block,
 		.nchildren = PARTS
 	};
         starpu_data_partition(handle, &f);

examples/filters/fmatrix.c

@@ -78,7 +78,7 @@ int main(int argc, char **argv)
         /* Partition the matrix in PARTS sub-matrices */
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = PARTS
 	};
 	starpu_data_partition(handle, &f);

examples/filters/fvector.c

@@ -66,7 +66,7 @@ int main(int argc, char **argv)
         /* Partition the vector in PARTS sub-vectors */
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = PARTS
 	};
 	starpu_data_partition(handle, &f);

examples/filters/shadow.c

@@ -131,7 +131,7 @@ int main(int argc, char **argv)
 	 * combined. */
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_shadow_filter_func_vector,
+		.filter_func = starpu_vector_filter_block_shadow,
 		.nchildren = PARTS,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOW /* Shadow width */
 	};
@@ -140,7 +140,7 @@ int main(int argc, char **argv)
         /* Partition the destination vector in PARTS sub-vectors */
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = PARTS,
 	};
 	starpu_data_partition(handle2, &f2);

examples/filters/shadow2d.c

@@ -212,13 +212,13 @@ int main(int argc, char **argv)
 	 * combined. */
 	struct starpu_data_filter fy =
 	{
-		.filter_func = starpu_vertical_block_shadow_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block_shadow,
 		.nchildren = PARTSY,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOWY /* Shadow width */
 	};
 	struct starpu_data_filter fx =
 	{
-		.filter_func = starpu_block_shadow_filter_func,
+		.filter_func = starpu_matrix_filter_block_shadow,
 		.nchildren = PARTSX,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOWX /* Shadow width */
 	};
@@ -227,12 +227,12 @@ int main(int argc, char **argv)
         /* Partition the destination matrix in PARTSY*PARTSX sub-matrices */
 	struct starpu_data_filter fy2 =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = PARTSY,
 	};
 	struct starpu_data_filter fx2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = PARTSX,
 	};
 	starpu_data_map_filters(handle2, 2, &fy2, &fx2);

examples/filters/shadow3d.c

@@ -230,19 +230,19 @@ int main(int argc, char **argv)
 	 * combined. */
 	struct starpu_data_filter fz =
 	{
-		.filter_func = starpu_depth_block_shadow_filter_func_block,
+		.filter_func = starpu_block_filter_depth_block_shadow,
 		.nchildren = PARTSZ,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOWZ /* Shadow width */
 	};
 	struct starpu_data_filter fy =
 	{
-		.filter_func = starpu_vertical_block_shadow_filter_func_block,
+		.filter_func = starpu_block_filter_vertical_block_shadow,
 		.nchildren = PARTSY,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOWY /* Shadow width */
 	};
 	struct starpu_data_filter fx =
 	{
-		.filter_func = starpu_block_shadow_filter_func_block,
+		.filter_func = starpu_block_filter_block_shadow,
 		.nchildren = PARTSX,
 		.filter_arg_ptr = (void*)(uintptr_t) SHADOWX /* Shadow width */
 	};
@@ -251,17 +251,17 @@ int main(int argc, char **argv)
         /* Partition the destination matrix in PARTSZ*PARTSY*PARTSX sub-matrices */
 	struct starpu_data_filter fz2 =
 	{
-		.filter_func = starpu_depth_block_filter_func_block,
+		.filter_func = starpu_block_filter_depth_block,
 		.nchildren = PARTSZ,
 	};
 	struct starpu_data_filter fy2 =
 	{
-		.filter_func = starpu_vertical_block_filter_func_block,
+		.filter_func = starpu_block_filter_vertical_block,
 		.nchildren = PARTSY,
 	};
 	struct starpu_data_filter fx2 =
 	{
-		.filter_func = starpu_block_filter_func_block,
+		.filter_func = starpu_block_filter_block,
 		.nchildren = PARTSX,
 	};
 	starpu_data_map_filters(handle2, 3, &fz2, &fy2, &fx2);

examples/heat/dw_factolu.c

@@ -755,13 +755,13 @@ void dw_factoLU(float *matA, unsigned size,
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/heat/dw_factolu_grain.c

@@ -223,13 +223,13 @@ static void dw_factoLU_grain_inner(float *matA, unsigned size, unsigned inner_si
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/heat/dw_factolu_tag.c

@@ -301,13 +301,13 @@ void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks, u
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/lu/xlu.c

@@ -256,13 +256,13 @@ int STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigned
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/lu/xlu_implicit.c

@@ -156,13 +156,13 @@ int STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigned
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/lu/xlu_implicit_pivot.c

@@ -210,13 +210,13 @@ int STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size,
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/lu/xlu_pivot.c

@@ -345,13 +345,13 @@ int STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size,
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

examples/mult/xgemm.c

@@ -119,12 +119,12 @@ static void partition_mult_data(void)
 
 	struct starpu_data_filter vert;
 	memset(&vert, 0, sizeof(vert));
-	vert.filter_func = starpu_vertical_block_filter_func;
+	vert.filter_func = starpu_matrix_filter_vertical_block;
 	vert.nchildren = nslicesx;
 
 	struct starpu_data_filter horiz;
 	memset(&horiz, 0, sizeof(horiz));
-	horiz.filter_func = starpu_block_filter_func;
+	horiz.filter_func = starpu_matrix_filter_block;
 	horiz.nchildren = nslicesy;
 
 	starpu_data_partition(B_handle, &vert);

examples/pi/pi.c

@@ -114,7 +114,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = ntasks
 	};
 	

examples/ppm_downscaler/yuv_downscaler.c

@@ -95,13 +95,13 @@ static struct starpu_codelet ds_codelet =
 /* each block contains BLOCK_HEIGHT consecutive lines */
 static struct starpu_data_filter filter_y =
 {
-	.filter_func = starpu_block_filter_func,
+	.filter_func = starpu_matrix_filter_block,
 	.nchildren= HEIGHT/BLOCK_HEIGHT
 };
 
 static struct starpu_data_filter filter_uv =
 {
-	.filter_func = starpu_block_filter_func,
+	.filter_func = starpu_matrix_filter_block,
 	.nchildren = (HEIGHT/2)/BLOCK_HEIGHT
 };
 

examples/spmv/dw_block_spmv.c

@@ -121,17 +121,17 @@ void call_filters(void)
 	struct starpu_data_filter bcsr_f;
 	struct starpu_data_filter vector_in_f, vector_out_f;
 
-	bcsr_f.filter_func    = starpu_canonical_block_filter_bcsr;
+	bcsr_f.filter_func    = starpu_bcsr_filter_canonical_block;
 	bcsr_f.get_nchildren = get_bcsr_nchildren;
 	/* the children use a matrix interface ! */
 	bcsr_f.get_child_ops = get_bcsr_child_ops;
 
-	vector_in_f.filter_func = starpu_block_filter_func_vector;
+	vector_in_f.filter_func = starpu_vector_filter_block;
 	vector_in_f.nchildren  = size/c;
 	vector_in_f.get_nchildren  = NULL;
 	vector_in_f.get_child_ops  = NULL;
 	
-	vector_out_f.filter_func = starpu_block_filter_func_vector;
+	vector_out_f.filter_func = starpu_vector_filter_block;
 	vector_out_f.nchildren  = size/r;
 	vector_out_f.get_nchildren  = NULL;
 	vector_out_f.get_child_ops  = NULL;

examples/spmv/spmv.c

@@ -88,7 +88,7 @@ static struct starpu_data_filter csr_f =
 
 static struct starpu_data_filter vector_f =
 {
-	.filter_func = starpu_block_filter_func_vector,
+	.filter_func = starpu_vector_filter_block,
 	/* This value is defined later on */
 	.nchildren = -1,
 };

include/starpu_data_filters.h

@@ -58,28 +58,28 @@ void starpu_data_vmap_filters(starpu_data_handle_t root_data, unsigned nfilters,
 /* a few examples of filters */
 
 /* for BCSR */
-void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_bcsr_filter_canonical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_csr_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
 /* (filters for matrix interface) */
-void starpu_block_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_block_shadow_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_shadow_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_matrix_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_matrix_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_matrix_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_matrix_filter_vertical_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
 /* for vector */
-void starpu_block_filter_func_vector(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_block_shadow_filter_func_vector(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vector_list_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_vector_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_vector_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_vector_filter_list(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_vector_filter_divide_in_2(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
 /* for block */
-void starpu_block_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_block_shadow_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_shadow_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_depth_block_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
-void starpu_depth_block_shadow_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_vertical_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_depth_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
+void starpu_block_filter_depth_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
 #ifdef __cplusplus
 }

sched_ctx_hypervisor/examples/cholesky/cholesky_grain_tag.c

@@ -184,13 +184,13 @@ static void cholesky_grain_rec(float *matA, unsigned size, unsigned ld, unsigned
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

sched_ctx_hypervisor/examples/cholesky/cholesky_implicit.c

@@ -194,13 +194,13 @@ static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

sched_ctx_hypervisor/examples/cholesky/cholesky_tag.c

@@ -274,13 +274,13 @@ static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vertical_block_filter_func,
+		.filter_func = starpu_matrix_filter_vertical_block,
 		.nchildren = nblocks
 	};
 
 	struct starpu_data_filter f2 =
 	{
-		.filter_func = starpu_block_filter_func,
+		.filter_func = starpu_matrix_filter_block,
 		.nchildren = nblocks
 	};
 

src/datawizard/interfaces/bcsr_filters.c

@@ -20,7 +20,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nparts)
+void starpu_bcsr_filter_canonical_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nparts)
 {
 	struct starpu_bcsr_interface *bcsr_father = (struct starpu_bcsr_interface *) father_interface;
 	/* each chunk becomes a small dense matrix */

src/datawizard/interfaces/block_filters.c

@@ -19,7 +19,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_block_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
@@ -53,7 +53,7 @@ void starpu_block_filter_func_block(void *father_interface, void *child_interfac
 	}
 }
 
-void starpu_block_shadow_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
@@ -91,7 +91,7 @@ void starpu_block_shadow_filter_func_block(void *father_interface, void *child_i
 	}
 }
 
-void starpu_vertical_block_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_vertical_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
@@ -125,7 +125,7 @@ void starpu_vertical_block_filter_func_block(void *father_interface, void *child
 	}
 }
 
-void starpu_vertical_block_shadow_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_vertical_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
@@ -164,7 +164,7 @@ void starpu_vertical_block_shadow_filter_func_block(void *father_interface, void
 	}
 }
 
-void starpu_depth_block_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_depth_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
@@ -199,7 +199,7 @@ void starpu_depth_block_filter_func_block(void *father_interface, void *child_in
 	}
 }
 
-void starpu_depth_block_shadow_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
+void starpu_block_filter_depth_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
         struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;

src/datawizard/interfaces/csr_filters.c

@@ -20,7 +20,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_csr_filter_vertical_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
 	struct starpu_csr_interface *csr_father = (struct starpu_csr_interface *) father_interface;
 	struct starpu_csr_interface *csr_child = (struct starpu_csr_interface *) child_interface;

src/datawizard/interfaces/matrix_filters.c

@@ -23,7 +23,7 @@
 /*
  * an example of a dummy partition function : blocks ...
  */
-void starpu_block_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_matrix_filter_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
 	struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
 	struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
@@ -59,7 +59,7 @@ void starpu_block_filter_func(void *father_interface, void *child_interface, STA
 /*
  * an example of a dummy partition function : blocks ...
  */
-void starpu_block_shadow_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_matrix_filter_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
 	struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
 	struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
@@ -97,7 +97,7 @@ void starpu_block_shadow_filter_func(void *father_interface, void *child_interfa
 	}
 }
 
-void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_matrix_filter_vertical_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
         struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
@@ -130,7 +130,7 @@ void starpu_vertical_block_filter_func(void *father_interface, void *child_inter
 	}
 }
 
-void starpu_vertical_block_shadow_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_matrix_filter_vertical_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
         struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;

src/datawizard/interfaces/vector_filters.c

@@ -20,7 +20,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_block_filter_func_vector(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_vector_filter_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
         struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;
@@ -48,7 +48,7 @@ void starpu_block_filter_func_vector(void *father_interface, void *child_interfa
 }
 
 
-void starpu_block_shadow_filter_func_vector(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
+void starpu_vector_filter_block_shadow(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
         struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;
@@ -80,7 +80,7 @@ void starpu_block_shadow_filter_func_vector(void *father_interface, void *child_
 }
 
 
-void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nchunks)
+void starpu_vector_filter_divide_in_2(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nchunks)
 {
         /* there cannot be more than 2 chunks */
 	STARPU_ASSERT_MSG(id < 2, "Only %d parts", id);
@@ -125,7 +125,7 @@ void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_i
 }
 
 
-void starpu_vector_list_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nchunks)
+void starpu_vector_filter_list(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nchunks)
 {
         struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
         struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;

tests/datawizard/acquire_cb_insert.c

@@ -87,7 +87,7 @@ int main(int argc, char **argv)
 	/* Partition f */
 	struct starpu_data_filter filter =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = M,
 	};
 	starpu_data_partition(f_handle, &filter);

tests/datawizard/data_lookup.c

@@ -108,7 +108,7 @@ static void test_filters(void)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = CHILDREN_COUNT
 	};
 	starpu_data_partition(handle, &f);

tests/datawizard/gpu_register.c

@@ -125,7 +125,7 @@ test_cuda(void)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = pieces,
 	};
 
@@ -221,7 +221,7 @@ test_opencl(void)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = pieces,
 	};
 

tests/datawizard/in_place_partition.c

@@ -55,7 +55,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = n,
 	};
 

tests/datawizard/partition_lazy.c

@@ -56,7 +56,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = n > 1 ? n : 2,
 	};
 

tests/datawizard/unpartition.c

@@ -78,7 +78,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_vector_divide_in_2_filter_func,
+		.filter_func = starpu_vector_filter_divide_in_2,
 		/* there are only 2 children */
 		.nchildren = 2,
 		/* the length of the first part */

tests/overlap/overlap.c

@@ -98,7 +98,7 @@ int main(int argc, char **argv)
 
 	struct starpu_data_filter f =
 	{
-		.filter_func = starpu_block_filter_func_vector,
+		.filter_func = starpu_vector_filter_block,
 		.nchildren = NTASKS
 	};
 

tools/dev/rename_filter.sed

@@ -0,0 +1,34 @@
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2013  Centre National de la Recherche Scientifique
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+
+s/\bstarpu_canonical_block_filter_bcsr\b/starpu_bcsr_filter_canonical_block/g
+s/\bstarpu_vertical_block_filter_func_csr\b/starpu_csr_filter_vertical_block/g
+
+s/\bstarpu_block_filter_func\b/starpu_matrix_filter_block/g
+s/\bstarpu_block_shadow_filter_func\b/starpu_matrix_filter_block_shadow/g
+s/\bstarpu_vertical_block_filter_func\b/starpu_matrix_filter_vertical_block/g
+s/\bstarpu_vertical_block_shadow_filter_func\b/starpu_matrix_filter_vertical_block_shadow/g
+
+s/\bstarpu_block_filter_func_vector\b/starpu_vector_filter_block/g
+s/\bstarpu_block_shadow_filter_func_vector\b/starpu_vector_filter_block_shadow/g
+s/\bstarpu_vector_list_filter_func\b/starpu_vector_filter_list/g
+s/\bstarpu_vector_divide_in_2_filter_func\b/starpu_vector_filter_divide_in_2/g
+
+s/\bstarpu_block_filter_func_block\b/starpu_block_filter_block/g
+s/\bstarpu_block_shadow_filter_func_block\b/starpu_block_filter_block_shadow/g
+s/\bstarpu_vertical_block_filter_func_block\b/starpu_block_filter_vertical_block/g
+s/\bstarpu_vertical_block_shadow_filter_func_block\b/starpu_block_filter_vertical_block_shadow/g
+s/\bstarpu_depth_block_filter_func_block\b/starpu_block_filter_depth_block/g
+s/\bstarpu_depth_block_shadow_filter_func_block\b/starpu_block_filter_depth_block_shadow/g

tools/dev/rename_filter.sh

@@ -0,0 +1,17 @@
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2010  Université de Bordeaux 1
+# Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+
+find . -type f -not -name rename_filter.sed -not -path "*svn*"|xargs sed -i -f $(dirname $0)/rename_filter.sed