- Rename "struct starpu_filter_t" into "struct starpu_data_filter" and remove

  the useless starpu_filter typedef.
- Rename starpu_map_filters into starpu_data_map_filters (and update the
  renaming script accordingly)

examples/audio/starpu_audio_processing.c

@@ -391,7 +391,7 @@ int main(int argc, char **argv)
 
 	starpu_vector_data_register(&A_handle, 0, (uintptr_t)A, niter*nsamples, sizeof(float));
 
-	starpu_filter f = 
+	struct starpu_data_filter f = 
 	{
 		.filter_func = starpu_block_filter_func_vector,
 		.nchildren = niter,

examples/axpy/axpy.c

@@ -109,7 +109,7 @@ int main(int argc, char **argv)
 	starpu_vector_data_register(&handle_y, 0, (uintptr_t)vec_y, N, sizeof(TYPE));
 
 	/* Divide the vector into blocks */
-	starpu_filter block_filter = {
+	struct starpu_data_filter block_filter = {
 		.filter_func = starpu_block_filter_func_vector,
 		.nchildren = NBLOCKS,
 		.get_nchildren = NULL,

examples/basic_examples/mult.c

@@ -21,7 +21,7 @@
  *  - how to declare dense matrices (starpu_matrix_data_register)
  *  - how to manipulate matrices within codelets (eg. descr[0].blas.ld)
  *  - how to use filters to partition the matrices into blocks
- *    (starpu_data_partition and starpu_map_filters)
+ *    (starpu_data_partition and starpu_data_map_filters)
  *  - how to unpartition data (starpu_data_unpartition) and how to stop
  *    monitoring data (starpu_data_unregister)
  *  - how to manipulate subsets of data (starpu_data_get_sub_data)
@@ -207,7 +207,7 @@ static void partition_mult_data(void)
 		ydim, ydim, xdim, sizeof(float));
 
 	/* A filter is a method to partition a data into disjoint chunks, it is
-	 * described by the means of the "starpu_filter" structure that
+	 * described by the means of the "struct starpu_data_filter" structure that
 	 * contains a function that is applied on a data handle to partition it
 	 * into smaller chunks, and an argument that is passed to the function
 	 * (eg. the number of blocks to create here).
@@ -216,14 +216,14 @@ static void partition_mult_data(void)
 	/* StarPU supplies some basic filters such as the partition of a matrix
 	 * into blocks, note that we are using a FORTRAN ordering so that the
 	 * name of the filters are a bit misleading */
-	starpu_filter f = {
+	struct starpu_data_filter f = {
 		.filter_func = starpu_vertical_block_filter_func,
 		.nchildren = nslicesx,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};
 		
-	starpu_filter f2 = {
+	struct starpu_data_filter f2 = {
 		.filter_func = starpu_block_filter_func,
 		.nchildren = nslicesy,
 		.get_nchildren = NULL,
@@ -270,14 +270,14 @@ static void partition_mult_data(void)
 	starpu_data_partition(B_handle, &f);
 	starpu_data_partition(A_handle, &f2);
 
-	/* starpu_map_filters is a variable-arity function, the first argument
+	/* starpu_data_map_filters is a variable-arity function, the first argument
 	 * is the handle of the data to partition, the second argument is the
 	 * number of filters to apply recursively. Filters are applied in the
 	 * same order as the arguments.
 	 * This would be equivalent to starpu_data_partition(C_handle, &f) and
 	 * then applying f2 on each sub-data (ie. each column of C)
 	 */
-	starpu_map_filters(C_handle, 2, &f, &f2);
+	starpu_data_map_filters(C_handle, 2, &f, &f2);
 }
 
 static struct starpu_perfmodel_t mult_perf_model = {
@@ -392,9 +392,9 @@ int main(__attribute__ ((unused)) int argc,
 		pthread_cond_wait(&cond, &mutex);
 	pthread_mutex_unlock(&mutex);
 
-	/* remove the filters applied by the means of starpu_map_filters; now
+	/* remove the filters applied by the means of starpu_data_map_filters; now
  	 * it's not possible to manipulate a subset of C using starpu_data_get_sub_data until
-	 * starpu_map_filters is called again on C_handle.
+	 * starpu_data_map_filters is called again on C_handle.
 	 * The second argument is the memory node where the different subsets
 	 * should be reassembled, 0 = main memory (RAM) */
 	starpu_data_unpartition(C_handle, 0);

examples/cholesky/dw_cholesky.c

@@ -242,19 +242,19 @@ void dw_cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	starpu_data_set_sequential_consistency_flag(dataA, 0);
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	_dw_cholesky(dataA, nblocks);
 

examples/cholesky/dw_cholesky_grain.c

@@ -172,19 +172,19 @@ static void _dw_cholesky_grain(float *matA, unsigned size, unsigned ld, unsigned
 
 	starpu_data_set_sequential_consistency_flag(dataA, 0);
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	for (k = 0; k < nbigblocks; k++)
 	{

examples/filters/filters.c

@@ -57,7 +57,7 @@ int main(int argc, char **argv)
 	starpu_vector_data_register(&handle, 0, (uintptr_t)vector, NX, sizeof(vector[0]));
 
         /* Partition the vector in PARTS sub-vectors */
-	starpu_filter f =
+	struct starpu_data_filter f =
 	{
 		.filter_func = starpu_block_filter_func_vector,
 		.nchildren = PARTS,

examples/heat/dw_factolu.c

@@ -728,19 +728,19 @@ void dw_factoLU(float *matA, unsigned size,
 	starpu_matrix_data_register(&dataA, 0, (uintptr_t)matA, ld, 
 			size, size, sizeof(float));
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	switch (version) {
 		case 1:

examples/heat/dw_factolu_grain.c

@@ -205,19 +205,19 @@ static void dw_factoLU_grain_inner(float *matA, unsigned size, unsigned inner_si
 	unsigned nblocks = size / blocksize;
 	unsigned maxk = inner_size / blocksize;
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 
 	/*

examples/heat/dw_factolu_tag.c

@@ -278,19 +278,19 @@ void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks, u
 	 * one block is now determined by 2 unsigned (i,j) */
 	starpu_matrix_data_register(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	dw_codelet_facto_v3(dataA, nblocks);
 

examples/lu/xlu.c

@@ -234,19 +234,19 @@ void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigne
 	/* We already enforce deps by hand */
 	starpu_data_set_sequential_consistency_flag(dataA, 0);
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	dw_codelet_facto_v3(dataA, nblocks);
 

examples/lu/xlu_implicit.c

@@ -141,19 +141,19 @@ void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigne
 	 * one block is now determined by 2 unsigned (i,j) */
 	starpu_matrix_data_register(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(TYPE));
 	
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	dw_codelet_facto_v3(dataA, nblocks);
 

examples/lu/xlu_implicit_pivot.c

@@ -189,19 +189,19 @@ void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size
 	 * one block is now determined by 2 unsigned (i,j) */
 	starpu_matrix_data_register(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(TYPE));
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	unsigned i;
 	for (i = 0; i < size; i++)

examples/lu/xlu_pivot.c

@@ -313,15 +313,15 @@ void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size
 	/* We already enforce deps by hand */
 	starpu_data_set_sequential_consistency_flag(dataA, 0);
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
 		f.filter_arg = nblocks;
 
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 		f2.filter_func = starpu_block_filter_func;
 		f2.filter_arg = nblocks;
 
-	starpu_map_filters(dataA, 2, &f, &f2);
+	starpu_data_map_filters(dataA, 2, &f, &f2);
 
 	unsigned i;
 	for (i = 0; i < size; i++)

examples/mult/dw_mult.c

@@ -166,13 +166,13 @@ static void partition_mult_data(void)
 	conf.m = ydim/nslicesy;
 	conf.n = xdim/nslicesx;
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 	f.filter_func = starpu_vertical_block_filter_func;
 	f.nchildren = nslicesx;
 	f.get_nchildren = NULL;
 	f.get_child_ops = NULL;
 		
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 	f2.filter_func = starpu_block_filter_func;
 	f2.nchildren = nslicesy;
 	f2.get_nchildren = NULL;
@@ -181,7 +181,7 @@ static void partition_mult_data(void)
 	starpu_data_partition(B_handle, &f);
 	starpu_data_partition(A_handle, &f2);
 
-	starpu_map_filters(C_handle, 2, &f, &f2);
+	starpu_data_map_filters(C_handle, 2, &f, &f2);
 }
 
 static starpu_codelet cl = {

examples/mult/xgemm.c

@@ -150,13 +150,13 @@ static void partition_mult_data(void)
 	conf.m = ydim/nslicesy;
 	conf.n = xdim/nslicesx;
 
-	starpu_filter f;
+	struct starpu_data_filter f;
 	f.filter_func = starpu_vertical_block_filter_func;
 	f.nchildren = nslicesx;
 	f.get_nchildren = NULL;
 	f.get_child_ops = NULL;
 		
-	starpu_filter f2;
+	struct starpu_data_filter f2;
 	f2.filter_func = starpu_block_filter_func;
 	f2.nchildren = nslicesy;
 	f2.get_nchildren = NULL;
@@ -165,7 +165,7 @@ static void partition_mult_data(void)
 	starpu_data_partition(B_handle, &f);
 	starpu_data_partition(A_handle, &f2);
 
-	starpu_map_filters(C_handle, 2, &f, &f2);
+	starpu_data_map_filters(C_handle, 2, &f, &f2);
 }
 
 static void unpartition_mult_data(void)

examples/pi/pi.c

@@ -96,7 +96,7 @@ int main(int argc, char **argv)
 	 * accessed by the CPU later on */
 	starpu_data_set_wb_mask(cnt_array_handle, (1<<0));
 
-	struct starpu_filter_t f = {
+	struct starpu_data_filter f = {
 		.filter_func = starpu_block_filter_func_vector,
 		.nchildren = ntasks,
 		.get_nchildren = NULL,

examples/ppm_downscaler/yuv_downscaler.c

@@ -106,21 +106,21 @@ static struct starpu_codelet_t ds_codelet = {
 };
 
 /* each block contains BLOCK_HEIGHT consecutive lines */
-static starpu_filter filter_y = {
+static struct starpu_data_filter filter_y = {
 	.filter_func = starpu_block_filter_func,
 	.nchildren= HEIGHT/BLOCK_HEIGHT,
 	.get_nchildren = NULL,
 	.get_child_ops = NULL
 };
 	
-static starpu_filter filter_u = {
+static struct starpu_data_filter filter_u = {
 	.filter_func = starpu_block_filter_func,
 	.nchildren = (HEIGHT/2)/BLOCK_HEIGHT,
 	.get_nchildren = NULL,
 	.get_child_ops = NULL
 };
 
-static starpu_filter filter_v = {
+static struct starpu_data_filter filter_v = {
 	.filter_func = starpu_block_filter_func,
 	.nchildren = (HEIGHT/2)/BLOCK_HEIGHT,
 	.get_nchildren = NULL,

examples/spmv/dw_block_spmv.c

@@ -90,12 +90,12 @@ void init_problem_callback(void *arg)
 	}
 }
 
-unsigned get_bcsr_nchildren(__attribute__((unused)) starpu_filter *f, starpu_data_handle handle)
+unsigned get_bcsr_nchildren(__attribute__((unused)) struct starpu_data_filter *f, starpu_data_handle handle)
 {
   return (unsigned)starpu_bcsr_get_nnz(handle);
 }
 
-struct starpu_data_interface_ops_t *get_bcsr_child_ops(__attribute__((unused)) starpu_filter *f, __attribute__((unused)) unsigned child) 
+struct starpu_data_interface_ops_t *get_bcsr_child_ops(__attribute__((unused)) struct starpu_data_filter *f, __attribute__((unused)) unsigned child) 
 {
   return &_starpu_interface_matrix_ops;
 }
@@ -103,8 +103,8 @@ struct starpu_data_interface_ops_t *get_bcsr_child_ops(__attribute__((unused)) s
 void call_filters(void)
 {
 
-	starpu_filter bcsr_f;
-	starpu_filter vector_in_f, vector_out_f;
+	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.get_nchildren = get_bcsr_nchildren;

examples/spmv/dw_spmv.c

@@ -234,7 +234,7 @@ void call_spmv_codelet_filters(void)
 {
 
 	/* partition the data along a block distribution */
-	starpu_filter csr_f, vector_f;
+	struct starpu_data_filter csr_f, vector_f;
 	csr_f.filter_func = starpu_vertical_block_filter_func_csr;
 	csr_f.nchildren = nblocks;
 	csr_f.get_nchildren = NULL;

include/starpu_data_filters.h

@@ -26,16 +26,16 @@ extern "C" {
 
 struct starpu_data_interface_ops_t;
 
-typedef struct starpu_filter_t {
-  void (*filter_func)(void *father_interface, void *child_interface, struct starpu_filter_t *, unsigned id, unsigned nparts);
-        unsigned (*get_nchildren)(struct starpu_filter_t *, starpu_data_handle initial_handle);
-        struct starpu_data_interface_ops_t *(*get_child_ops)(struct starpu_filter_t *, unsigned id);
+struct starpu_data_filter {
+	void (*filter_func)(void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts);
+        unsigned (*get_nchildren)(struct starpu_data_filter *, starpu_data_handle initial_handle);
+        struct starpu_data_interface_ops_t *(*get_child_ops)(struct starpu_data_filter *, unsigned id);
         unsigned filter_arg;
         unsigned nchildren;
         void *filter_arg_ptr;
-} starpu_filter;
+};
 
-void starpu_data_partition(starpu_data_handle initial_handle, starpu_filter *f);
+void starpu_data_partition(starpu_data_handle initial_handle, struct starpu_data_filter *f);
 void starpu_data_unpartition(starpu_data_handle root_data, uint32_t gathering_node);
 
 starpu_data_handle starpu_data_get_child(starpu_data_handle handle, unsigned i);
@@ -43,22 +43,22 @@ starpu_data_handle starpu_data_get_child(starpu_data_handle handle, unsigned i);
 /* unsigned list */
 starpu_data_handle starpu_data_get_sub_data(starpu_data_handle root_data, unsigned depth, ... );
 
-/* starpu_filter * list */
-void starpu_map_filters(starpu_data_handle root_data, unsigned nfilters, ...);
+/* struct starpu_data_filter * list */
+void starpu_data_map_filters(starpu_data_handle root_data, unsigned nfilters, ...);
 
 /* a few examples of filters */
 
 /* for BCSR */
-void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
+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);
 /* (filters for BLAS interface) */
-void starpu_block_filter_func(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
-void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
+void starpu_block_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);
 
 /* for vector */
-void starpu_block_filter_func_vector(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
-void starpu_vector_list_filter_func(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
-void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, unsigned nparts);
+void starpu_block_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);
 
 #ifdef __cplusplus
 }

src/datawizard/filters.c

@@ -17,21 +17,21 @@
 #include <datawizard/filters.h>
 #include <datawizard/footprint.h>
 
-static void starpu_data_create_children(starpu_data_handle handle, unsigned nchildren, starpu_filter *f);
+static void starpu_data_create_children(starpu_data_handle handle, unsigned nchildren, struct starpu_data_filter *f);
 
 /*
- * This function applies a starpu_filter on all the elements of a partition
+ * This function applies a data filter on all the elements of a partition
  */
-static void map_filter(starpu_data_handle root_handle, starpu_filter *f)
+static void map_filter(starpu_data_handle root_handle, struct starpu_data_filter *f)
 {
-	/* we need to apply the starpu_filter on all leaf of the tree */
+	/* we need to apply the data filter on all leaf of the tree */
 	if (root_handle->nchildren == 0)
 	{
 		/* this is a leaf */
 		starpu_data_partition(root_handle, f);
 	}
 	else {
-		/* try to apply the starpu_filter recursively */
+		/* try to apply the data filter recursively */
 		unsigned child;
 		for (child = 0; child < root_handle->nchildren; child++)
 		{
@@ -39,15 +39,15 @@ static void map_filter(starpu_data_handle root_handle, starpu_filter *f)
 		}
 	}
 }
-void starpu_map_filters(starpu_data_handle root_handle, unsigned nfilters, ...)
+void starpu_data_map_filters(starpu_data_handle root_handle, unsigned nfilters, ...)
 {
 	unsigned i;
 	va_list pa;
 	va_start(pa, nfilters);
 	for (i = 0; i < nfilters; i++)
 	{
-		starpu_filter *next_filter;
-		next_filter = va_arg(pa, starpu_filter *);
+		struct starpu_data_filter *next_filter;
+		next_filter = va_arg(pa, struct starpu_data_filter *);
 
 		STARPU_ASSERT(next_filter);
 
@@ -89,7 +89,7 @@ starpu_data_handle starpu_data_get_sub_data(starpu_data_handle root_handle, unsi
 	return current_handle;
 }
 
-void starpu_data_partition(starpu_data_handle initial_handle, starpu_filter *f)
+void starpu_data_partition(starpu_data_handle initial_handle, struct starpu_data_filter *f)
 {
 	unsigned nparts;
 	unsigned i;
@@ -244,7 +244,7 @@ void starpu_data_unpartition(starpu_data_handle root_handle, uint32_t gathering_
 }
 
 /* each child may have his own interface type */
-static void starpu_data_create_children(starpu_data_handle handle, unsigned nchildren, starpu_filter *f)
+static void starpu_data_create_children(starpu_data_handle handle, unsigned nchildren, struct starpu_data_filter *f)
 {
 	handle->children = calloc(nchildren, sizeof(struct starpu_data_state_t));
 	STARPU_ASSERT(handle->children);

src/datawizard/interfaces/bcsr_filters.c

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

src/datawizard/interfaces/csr_filters.c

@@ -18,7 +18,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, __attribute__((unused)) starpu_filter *f, unsigned id, unsigned nchunks)
+void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, __attribute__((unused)) struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
 	starpu_csr_interface_t *csr_father = father_interface;
 	starpu_csr_interface_t *csr_child = child_interface;

src/datawizard/interfaces/matrix_filters.c

@@ -21,7 +21,7 @@
 /*
  * an example of a dummy partition function : blocks ...
  */
-void starpu_block_filter_func(void *father_interface, void *child_interface, __attribute__((unused)) starpu_filter *f, unsigned id, unsigned nchunks)
+void starpu_block_filter_func(void *father_interface, void *child_interface, __attribute__((unused)) struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
        starpu_matrix_interface_t *matrix_father = father_interface;
        starpu_matrix_interface_t *matrix_child = child_interface;
@@ -52,7 +52,7 @@ void starpu_block_filter_func(void *father_interface, void *child_interface, __a
 	}
 }
 
-void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, __attribute__((unused)) starpu_filter *f, unsigned id, unsigned nchunks)
+void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, __attribute__((unused)) struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         starpu_matrix_interface_t *matrix_father = father_interface;
         starpu_matrix_interface_t *matrix_child = child_interface;

src/datawizard/interfaces/vector_filters.c

@@ -18,7 +18,7 @@
 #include <common/config.h>
 #include <datawizard/filters.h>
 
-void starpu_block_filter_func_vector(void *father_interface, void *child_interface, __attribute__((unused)) starpu_filter *f, unsigned id, unsigned nchunks)
+void starpu_block_filter_func_vector(void *father_interface, void *child_interface, __attribute__((unused)) struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
         starpu_vector_interface_t *vector_father = father_interface;
         starpu_vector_interface_t *vector_child = child_interface;
@@ -45,7 +45,7 @@ void starpu_block_filter_func_vector(void *father_interface, void *child_interfa
 }
 
 
-void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, starpu_filter *f, unsigned id, __attribute__((unused)) unsigned nchunks)
+void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, __attribute__((unused)) unsigned nchunks)
 {
         /* there cannot be more than 2 chunks */
         STARPU_ASSERT(id < 2);
@@ -86,7 +86,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, starpu_filter *f, unsigned id, __attribute__((unused)) unsigned nchunks)
+void starpu_vector_list_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, __attribute__((unused)) unsigned nchunks)
 {
         starpu_vector_interface_t *vector_father = father_interface;
         starpu_vector_interface_t *vector_child = child_interface;

tests/datawizard/unpartition.c

@@ -69,7 +69,7 @@ int main(int argc, char **argv)
 
 	starpu_vector_data_register(&v_handle, 0, (uintptr_t)buffer, VECTORSIZE, sizeof(char));
 
-	starpu_filter f = {
+	struct starpu_data_filter f = {
 		.filter_func = starpu_vector_divide_in_2_filter_func,
 		/* there are only 2 children */
 		.nchildren = 2,
@@ -82,7 +82,7 @@ int main(int argc, char **argv)
 	unsigned iter;
 	for (iter = 0; iter < NITER; iter++)
 	{
-		starpu_map_filters(v_handle, 1, &f);
+		starpu_data_map_filters(v_handle, 1, &f);
 	
 		ret = use_handle(starpu_data_get_sub_data(v_handle, 1, 0));
 		if (ret == -ENODEV)

tests/overlap/overlap.c

@@ -83,7 +83,7 @@ int main(int argc, char **argv)
 	starpu_vector_data_register(&handle, 0, (uintptr_t)buffer,
 					NTASKS*VECTORSIZE, sizeof(char));
 
-	starpu_filter f =
+	struct starpu_data_filter f =
 	{
 		.filter_func = starpu_block_filter_func_vector,
 		.nchildren = NTASKS,