the starpu_filter structure now contains a nchildren field. This help resolving an ambiguity with the get_nchildren function, which now serves to compute non-trivial number of children. As a result, filter_arg is now used as an additional parameter in some specific filters, e.g starpu_divide_in_2_filter_func.

examples/audio/starpu_audio_processing.c

@@ -394,7 +394,7 @@ int main(int argc, char **argv)
 	starpu_filter f = 
 	{
 		.filter_func = starpu_block_filter_func_vector,
-		.filter_arg = niter,
+		.nchildren = niter,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};

examples/axpy/axpy.c

@@ -111,7 +111,7 @@ int main(int argc, char **argv)
 	/* Divide the vector into blocks */
 	starpu_filter block_filter = {
 		.filter_func = starpu_block_filter_func_vector,
-		.filter_arg = NBLOCKS,
+		.nchildren = NBLOCKS,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};

examples/basic_examples/mult.c

@@ -218,14 +218,14 @@ static void partition_mult_data(void)
 	 * name of the filters are a bit misleading */
 	starpu_filter f = {
 		.filter_func = starpu_vertical_block_filter_func,
-		.filter_arg = nslicesx,
+		.nchildren = nslicesx,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};
 		
 	starpu_filter f2 = {
 		.filter_func = starpu_block_filter_func,
-		.filter_arg = nslicesy,
+		.nchildren = nslicesy,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};

examples/cholesky/dw_cholesky.c

@@ -244,13 +244,13 @@ void dw_cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/cholesky/dw_cholesky_grain.c

@@ -174,13 +174,13 @@ static void _dw_cholesky_grain(float *matA, unsigned size, unsigned ld, unsigned
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/filters/filters.c

@@ -60,7 +60,7 @@ int main(int argc, char **argv)
 	starpu_filter f =
 	{
 		.filter_func = starpu_block_filter_func_vector,
-		.filter_arg = PARTS,
+		.nchildren = PARTS,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};

examples/heat/dw_factolu.c

@@ -730,13 +730,13 @@ void dw_factoLU(float *matA, unsigned size,
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/heat/dw_factolu_grain.c

@@ -207,13 +207,13 @@ static void dw_factoLU_grain_inner(float *matA, unsigned size, unsigned inner_si
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/heat/dw_factolu_tag.c

@@ -280,13 +280,13 @@ void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks, u
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/lu/xlu.c

@@ -236,13 +236,13 @@ void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigne
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/lu/xlu_implicit.c

@@ -143,13 +143,13 @@ void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigne
 	
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/lu/xlu_implicit_pivot.c

@@ -191,13 +191,13 @@ void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;
-		f.filter_arg = nblocks;
+		f.nchildren = nblocks;
 		f.get_nchildren = NULL;
 		f.get_child_ops = NULL;
 
 	starpu_filter f2;
 		f2.filter_func = starpu_block_filter_func;
-		f2.filter_arg = nblocks;
+		f2.nchildren = nblocks;
 		f2.get_nchildren = NULL;
 		f2.get_child_ops = NULL;
 

examples/mult/dw_mult.c

@@ -168,13 +168,13 @@ static void partition_mult_data(void)
 
 	starpu_filter f;
 	f.filter_func = starpu_vertical_block_filter_func;
-	f.filter_arg = nslicesx;
+	f.nchildren = nslicesx;
 	f.get_nchildren = NULL;
 	f.get_child_ops = NULL;
 		
 	starpu_filter f2;
 	f2.filter_func = starpu_block_filter_func;
-	f2.filter_arg = nslicesy;
+	f2.nchildren = nslicesy;
 	f2.get_nchildren = NULL;
 	f2.get_child_ops = NULL;
 		

examples/mult/xgemm.c

@@ -152,13 +152,13 @@ static void partition_mult_data(void)
 
 	starpu_filter f;
 	f.filter_func = starpu_vertical_block_filter_func;
-	f.filter_arg = nslicesx;
+	f.nchildren = nslicesx;
 	f.get_nchildren = NULL;
 	f.get_child_ops = NULL;
 		
 	starpu_filter f2;
 	f2.filter_func = starpu_block_filter_func;
-	f2.filter_arg = nslicesy;
+	f2.nchildren = nslicesy;
 	f2.get_nchildren = NULL;
 	f2.get_child_ops = NULL;
 		

examples/pi/pi.c

@@ -98,7 +98,7 @@ int main(int argc, char **argv)
 
 	struct starpu_filter_t f = {
 		.filter_func = starpu_block_filter_func_vector,
-		.filter_arg = ntasks,
+		.nchildren = ntasks,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};

examples/ppm_downscaler/yuv_downscaler.c

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

examples/spmv/dw_block_spmv.c

@@ -90,9 +90,9 @@ void init_problem_callback(void *arg)
 	}
 }
 
-unsigned get_bcsr_nchildren(starpu_filter *f, starpu_data_handle handle)
+unsigned get_bcsr_nchildren(__attribute__((unused)) starpu_filter *f, starpu_data_handle handle)
 {
-  return handle->ops->nnz;
+  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) 

examples/spmv/dw_spmv.c

@@ -230,27 +230,19 @@ static void create_data(void)
 
 }
 
-unsigned get_csr_nchildren(starpu_filter *f, starpu_data_handle initial_handle)
-{
-  uint32_t arg = f->filter_arg;
-  uint32_t nrow = starpu_csr_get_nrow(initial_handle);
-
-  return STARPU_MIN(nrow, arg);
-}
-
 void call_spmv_codelet_filters(void)
 {
 
 	/* partition the data along a block distribution */
 	starpu_filter csr_f, vector_f;
-	csr_f.filter_func    = starpu_vertical_block_filter_func_csr;
-	csr_f.filter_arg     = nblocks;
-	csr_f.get_nchildren = get_csr_nchildren;
+	csr_f.filter_func = starpu_vertical_block_filter_func_csr;
+	csr_f.nchildren = nblocks;
+	csr_f.get_nchildren = NULL;
 	/* the children also use a csr interface */
 	csr_f.get_child_ops = NULL;
 
 	vector_f.filter_func = starpu_block_filter_func_vector;
-	vector_f.filter_arg  = nblocks;
+	vector_f.nchildren = nblocks;
 	vector_f.get_nchildren = NULL;
 	vector_f.get_child_ops = NULL;
 

include/starpu_data_filters.h

@@ -31,6 +31,7 @@ typedef struct starpu_filter_t {
         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);
         unsigned filter_arg;
+        unsigned nchildren;
         void *filter_arg_ptr;
 } starpu_filter;
 

src/datawizard/filters.c

@@ -102,7 +102,7 @@ void starpu_data_partition(starpu_data_handle initial_handle, starpu_filter *f)
 	if (f->get_nchildren)
 	  nparts = f->get_nchildren(f, initial_handle);
 	else
-	  nparts = f->filter_arg;
+	  nparts = f->nchildren;
 
 	STARPU_ASSERT(nparts > 0);
 

src/datawizard/interfaces/bcsr_filters.c

@@ -20,7 +20,6 @@
 
 void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, __attribute__((unused)) starpu_filter *f, unsigned id, __attribute__((unused)) unsigned nparts)
 {
-        unsigned nchunks;
 	struct starpu_bcsr_interface_s *bcsr_father = father_interface;
 	/* each chunk becomes a small dense matrix */
 	starpu_matrix_interface_t *matrix_child = child_interface;
@@ -33,9 +32,6 @@ void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_inte
 	/* size of the tiles */
 	uint32_t r = bcsr_father->r;
 	uint32_t c = bcsr_father->c;
-
-	/* we create as many subdata as there are blocks ... */
-	nchunks = nnz;
 	
 	uint32_t ptr_offset = c*r*id*elemsize;
 

src/datawizard/interfaces/matrix_filters.c

@@ -30,6 +30,8 @@ void starpu_block_filter_func(void *father_interface, void *child_interface, __a
 	uint32_t ny = matrix_father->ny;
 	size_t elemsize = matrix_father->elemsize;
 
+	STARPU_ASSERT(nchunks <= nx);
+
 	size_t chunk_size = ((size_t)nx + nchunks - 1)/nchunks;
 	size_t offset = (size_t)id*chunk_size*elemsize;
 	
@@ -59,6 +61,8 @@ void starpu_vertical_block_filter_func(void *father_interface, void *child_inter
 	uint32_t ny = matrix_father->ny;
 	size_t elemsize = matrix_father->elemsize;
 
+	STARPU_ASSERT(nchunks <= ny);
+
 	size_t chunk_size = ((size_t)ny + nchunks - 1)/nchunks;
 	size_t child_ny = 
 	  STARPU_MIN(chunk_size, (size_t)ny - (size_t)id*chunk_size);

src/datawizard/interfaces/vector_filters.c

@@ -22,11 +22,12 @@ void starpu_block_filter_func_vector(void *father_interface, void *child_interfa
 {
         starpu_vector_interface_t *vector_father = father_interface;
         starpu_vector_interface_t *vector_child = child_interface;
-
-        uint32_t nx = vector_father->nx;
+	
+	uint32_t nx = vector_father->nx;
 	size_t elemsize = vector_father->elemsize;
 
-	/* actually create all the chunks */
+	STARPU_ASSERT(nchunks <= nx);
+
 	uint32_t chunk_size = (nx + nchunks - 1)/nchunks;
 	size_t offset = id*chunk_size*elemsize;
 

tests/datawizard/unpartition.c

@@ -59,12 +59,6 @@ int use_handle(starpu_data_handle handle)
 	return ret;
 }
 
-/* there are 2 children */
-unsigned get_vector_nchildren(__attribute__((unused)) starpu_filter *f, __attribute__((unused)) starpu_data_handle initial_handle)
-{
-  return 2;
-}
-
 int main(int argc, char **argv)
 {
 	int ret;
@@ -77,8 +71,11 @@ int main(int argc, char **argv)
 
 	starpu_filter f = {
 		.filter_func = starpu_vector_divide_in_2_filter_func,
+		/* there are only 2 children */
+		.nchildren = 2,
+		/* the length of the first part */
 		.filter_arg = VECTORSIZE/2,
-		.get_nchildren = get_vector_nchildren,
+		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};
 

tests/overlap/overlap.c

@@ -86,7 +86,7 @@ int main(int argc, char **argv)
 	starpu_filter f =
 	{
 		.filter_func = starpu_block_filter_func_vector,
-		.filter_arg = NTASKS,
+		.nchildren = NTASKS,
 		.get_nchildren = NULL,
 		.get_child_ops = NULL
 	};