mpi/tests: fix spacing

mpi/tests/block_interface.c

@@ -134,8 +134,8 @@ int main(int argc, char **argv)
 
 	if (rank == 0 || rank == 1)
 	{
-	     starpu_data_unregister(block_handle);
-	     free(block);
+		starpu_data_unregister(block_handle);
+		free(block);
 	}
 	starpu_mpi_shutdown();
 	starpu_shutdown();

mpi/tests/block_interface_pinned.c

@@ -134,8 +134,8 @@ int main(int argc, char **argv)
 
 	if (rank == 0 || rank == 1)
 	{
-	     starpu_data_unregister(block_handle);
-	     starpu_free(block);
+		starpu_data_unregister(block_handle);
+		starpu_free(block);
 	}
 
 	FPRINTF(stdout, "Rank %d is done\n", rank);

mpi/tests/insert_task.c

@@ -23,15 +23,15 @@ void func_cpu(void *descr[], __attribute__ ((unused)) void *_args)
 	unsigned *x = (unsigned *)STARPU_VARIABLE_GET_PTR(descr[0]);
 	unsigned *y = (unsigned *)STARPU_VARIABLE_GET_PTR(descr[1]);
 
-        FPRINTF(stdout, "VALUES: %u %u\n", *x, *y);
-        *x = (*x + *y) / 2;
+	FPRINTF(stdout, "VALUES: %u %u\n", *x, *y);
+	*x = (*x + *y) / 2;
 }
 
 struct starpu_codelet mycodelet =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_RW, STARPU_R}
 };
 
@@ -41,16 +41,16 @@ struct starpu_codelet mycodelet =
 /* Returns the MPI node number where data indexes index is */
 int my_distrib(int x, int y, int nb_nodes)
 {
-        return x % nb_nodes;
+	return x % nb_nodes;
 }
 
 
 int main(int argc, char **argv)
 {
-        int rank, size, x, y;
-        int value=0, ret;
-        unsigned matrix[X][Y];
-        starpu_data_handle_t data_handles[X][Y];
+	int rank, size, x, y;
+	int value=0, ret;
+	unsigned matrix[X][Y];
+	starpu_data_handle_t data_handles[X][Y];
 
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -59,81 +59,83 @@ int main(int argc, char **argv)
 	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 	MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-        for(x = 0; x < X; x++)
+	for(x = 0; x < X; x++)
 	{
-                for (y = 0; y < Y; y++)
+		for (y = 0; y < Y; y++)
 		{
-                        matrix[x][y] = (rank+1)*10 + value;
-                        value++;
-                }
-        }
+			matrix[x][y] = (rank+1)*10 + value;
+			value++;
+		}
+	}
 #if 0
-        for(x = 0; x < X; x++) {
-                FPRINTF(stdout, "[%d] ", rank);
-                for (y = 0; y < Y; y++) {
-                        FPRINTF(stdout, "%3d ", matrix[x][y]);
-                }
-                FPRINTF(stdout, "\n");
-        }
+	for(x = 0; x < X; x++)
+	{
+		FPRINTF(stdout, "[%d] ", rank);
+		for (y = 0; y < Y; y++)
+		{
+			FPRINTF(stdout, "%3d ", matrix[x][y]);
+		}
+		FPRINTF(stdout, "\n");
+	}
 #endif
 
-        for(x = 0; x < X; x++)
+	for(x = 0; x < X; x++)
 	{
-                for (y = 0; y < Y; y++)
+		for (y = 0; y < Y; y++)
 		{
-                        int mpi_rank = my_distrib(x, y, size);
-                        if (mpi_rank == rank)
+			int mpi_rank = my_distrib(x, y, size);
+			if (mpi_rank == rank)
 			{
-                                //FPRINTF(stderr, "[%d] Owning data[%d][%d]\n", rank, x, y);
-                                starpu_variable_data_register(&data_handles[x][y], 0, (uintptr_t)&(matrix[x][y]), sizeof(unsigned));
-                        }
-                        else
+				//FPRINTF(stderr, "[%d] Owning data[%d][%d]\n", rank, x, y);
+				starpu_variable_data_register(&data_handles[x][y], 0, (uintptr_t)&(matrix[x][y]), sizeof(unsigned));
+			}
+			else
 			{
-                                /* I don't own that index, but will need it for my computations */
-                                //FPRINTF(stderr, "[%d] Neighbour of data[%d][%d]\n", rank, x, y);
-                                starpu_variable_data_register(&data_handles[x][y], -1, (uintptr_t)NULL, sizeof(unsigned));
-                        }
-                        if (data_handles[x][y])
+				/* I don't own that index, but will need it for my computations */
+				//FPRINTF(stderr, "[%d] Neighbour of data[%d][%d]\n", rank, x, y);
+				starpu_variable_data_register(&data_handles[x][y], -1, (uintptr_t)NULL, sizeof(unsigned));
+			}
+			if (data_handles[x][y])
 			{
-                                starpu_data_set_rank(data_handles[x][y], mpi_rank);
-                                starpu_data_set_tag(data_handles[x][y], (y*X)+x);
+				starpu_data_set_rank(data_handles[x][y], mpi_rank);
+				starpu_data_set_tag(data_handles[x][y], (y*X)+x);
 			}
-                }
-        }
+		}
+	}
 
-        ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[1][1], STARPU_R, data_handles[0][1], 0);
+	ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[1][1], STARPU_R, data_handles[0][1], 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
-        ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[3][1], STARPU_R, data_handles[0][1], 0);
+	ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[3][1], STARPU_R, data_handles[0][1], 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
-        ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[0][1], STARPU_R, data_handles[0][0], 0);
+	ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[0][1], STARPU_R, data_handles[0][0], 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
-        ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[3][1], STARPU_R, data_handles[0][1], 0);
+	ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[3][1], STARPU_R, data_handles[0][1], 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
 
-        FPRINTF(stderr, "Waiting ...\n");
-        starpu_task_wait_for_all();
+	FPRINTF(stderr, "Waiting ...\n");
+	starpu_task_wait_for_all();
 
-        for(x = 0; x < X; x++)
+	for(x = 0; x < X; x++)
 	{
-                for (y = 0; y < Y; y++)
+		for (y = 0; y < Y; y++)
 		{
-                        if (data_handles[x][y])
-                                starpu_data_unregister(data_handles[x][y]);
-                }
-        }
+			if (data_handles[x][y])
+				starpu_data_unregister(data_handles[x][y]);
+		}
+	}
 	starpu_mpi_shutdown();
 	starpu_shutdown();
 
 #if 0
-        for(x = 0; x < X; x++)
+	for(x = 0; x < X; x++)
 	{
-                FPRINTF(stdout, "[%d] ", rank);
-                for (y = 0; y < Y; y++)
+		FPRINTF(stdout, "[%d] ", rank);
+		for (y = 0; y < Y; y++)
 		{
-                        FPRINTF(stdout, "%3d ", matrix[x][y]);
-                }
-                FPRINTF(stdout, "\n");
-        }
+			FPRINTF(stdout, "%3d ", matrix[x][y]);
+		}
+		FPRINTF(stdout, "\n");
+	}
 #endif
 
 	return 0;

mpi/tests/insert_task_block.c

@@ -25,49 +25,49 @@ void func_cpu(void *descr[], __attribute__ ((unused)) void *_args)
 	int ny = (int)STARPU_MATRIX_GET_NY(descr[0]);
 	int ld = (int)STARPU_MATRIX_GET_LD(descr[0]);
 
-        int i, j;
-        unsigned sum=0;
+	int i, j;
+	unsigned sum=0;
 
 	for (i = 0; i < nx; i++)
 	{
 		for (j = 0; j < ny; j++)
 		{
-                        sum += matrix[i+j*ld];
-                }
-        }
+			sum += matrix[i+j*ld];
+		}
+	}
 	for (i = 0; i < nx; i++)
 	{
 		for (j = 0; j < ny; j++)
 		{
-                        matrix[i+j*ld] = sum;///(nx*ny);
-                }
-        }
+			matrix[i+j*ld] = sum;///(nx*ny);
+		}
+	}
 }
 
 struct starpu_codelet mycodelet =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 1,
+	.nbuffers = 1,
 	.modes = {STARPU_RW}
 };
 
-#define SIZE       6
-#define BLOCKS     3
+#define SIZE 6
+#define BLOCKS 3
 
 /* Returns the MPI node number where data indexes index is */
 int my_distrib(int x, int y, int nb_nodes)
 {
-        return x % nb_nodes;
+	return x % nb_nodes;
 }
 
 
 int main(int argc, char **argv)
 {
-        int rank, size, x, y;
-        int ret, value=0;
-        unsigned matrix[SIZE*SIZE];
-        starpu_data_handle_t data_handles[SIZE][SIZE];
+	int rank, size, x, y;
+	int ret, value=0;
+	unsigned matrix[SIZE*SIZE];
+	starpu_data_handle_t data_handles[SIZE][SIZE];
 
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -76,86 +76,88 @@ int main(int argc, char **argv)
 	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 	MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-        for(x = 0; x < SIZE; x++)
+	for(x = 0; x < SIZE; x++)
 	{
-                for (y = 0; y < SIZE; y++)
+		for (y = 0; y < SIZE; y++)
 		{
-                        matrix[x+y*SIZE] = rank*100 + value;
-                        value++;
-                }
-        }
+			matrix[x+y*SIZE] = rank*100 + value;
+			value++;
+		}
+	}
 #if 1
-        for(x = 0; x < SIZE; x++) {
-                FPRINTF(stdout, "[%d] ", rank);
-                for (y = 0; y < SIZE; y++) {
-                        FPRINTF(stdout, "%3u ", matrix[x+y*SIZE]);
-                }
-                FPRINTF(stdout, "\n");
-        }
+	for(x = 0; x < SIZE; x++)
+	{
+		FPRINTF(stdout, "[%d] ", rank);
+		for (y = 0; y < SIZE; y++)
+		{
+			FPRINTF(stdout, "%3u ", matrix[x+y*SIZE]);
+		}
+		FPRINTF(stdout, "\n");
+	}
 #endif
 
-        for(x = 0; x < BLOCKS ;  x++)
+	for(x = 0; x < BLOCKS ; x++)
 	{
-                for (y = 0; y < BLOCKS; y++)
+		for (y = 0; y < BLOCKS; y++)
 		{
-                        int mpi_rank = my_distrib(x, y, size);
-                        if (mpi_rank == rank)
+			int mpi_rank = my_distrib(x, y, size);
+			if (mpi_rank == rank)
 			{
-                                //FPRINTF(stderr, "[%d] Owning data[%d][%d]\n", rank, x, y);
-                                starpu_matrix_data_register(&data_handles[x][y], 0, (uintptr_t)&(matrix[((SIZE/BLOCKS)*x) + ((SIZE/BLOCKS)*y) * SIZE]),
-                                                            SIZE, SIZE/BLOCKS, SIZE/BLOCKS, sizeof(unsigned));
-                        }
-                        else
+				//FPRINTF(stderr, "[%d] Owning data[%d][%d]\n", rank, x, y);
+				starpu_matrix_data_register(&data_handles[x][y], 0, (uintptr_t)&(matrix[((SIZE/BLOCKS)*x) + ((SIZE/BLOCKS)*y) * SIZE]),
+							    SIZE, SIZE/BLOCKS, SIZE/BLOCKS, sizeof(unsigned));
+			}
+			else
 			{
-                                /* I don't own that index, but will need it for my computations */
-                                //FPRINTF(stderr, "[%d] Neighbour of data[%d][%d]\n", rank, x, y);
-                                starpu_matrix_data_register(&data_handles[x][y], -1, (uintptr_t)&(matrix[((SIZE/BLOCKS)*x) + ((SIZE/BLOCKS)*y) * SIZE]),
-                                                            SIZE, SIZE/BLOCKS, SIZE/BLOCKS, sizeof(unsigned));
-                        }
-                        if (data_handles[x][y])
+				/* I don't own that index, but will need it for my computations */
+				//FPRINTF(stderr, "[%d] Neighbour of data[%d][%d]\n", rank, x, y);
+				starpu_matrix_data_register(&data_handles[x][y], -1, (uintptr_t)&(matrix[((SIZE/BLOCKS)*x) + ((SIZE/BLOCKS)*y) * SIZE]),
+							    SIZE, SIZE/BLOCKS, SIZE/BLOCKS, sizeof(unsigned));
+			}
+			if (data_handles[x][y])
 			{
-                                starpu_data_set_rank(data_handles[x][y], mpi_rank);
-                                starpu_data_set_tag(data_handles[x][y], (y*BLOCKS)+x);
+				starpu_data_set_rank(data_handles[x][y], mpi_rank);
+				starpu_data_set_tag(data_handles[x][y], (y*BLOCKS)+x);
 			}
-                }
-        }
+		}
+	}
 
-        for(x = 0; x < BLOCKS; x++)
+	for(x = 0; x < BLOCKS; x++)
 	{
-                for (y = 0; y < BLOCKS; y++)
+		for (y = 0; y < BLOCKS; y++)
 		{
-                        ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
+			ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
 						     STARPU_RW, data_handles[x][y],
 						     0);
 			STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
+		}
+	}
 
-                }
-        }
-
-        FPRINTF(stderr, "Waiting ...\n");
-        starpu_task_wait_for_all();
+	FPRINTF(stderr, "Waiting ...\n");
+	starpu_task_wait_for_all();
 
-        for(x = 0; x < BLOCKS; x++)
+	for(x = 0; x < BLOCKS; x++)
 	{
-                for (y = 0; y < BLOCKS; y++)
+		for (y = 0; y < BLOCKS; y++)
 		{
-                        if (data_handles[x][y])
-                                starpu_data_unregister(data_handles[x][y]);
-                }
-        }
+			if (data_handles[x][y])
+				starpu_data_unregister(data_handles[x][y]);
+		}
+	}
 
 	starpu_mpi_shutdown();
 	starpu_shutdown();
 
 #if 1
-        for(x = 0; x < SIZE; x++)
+	for(x = 0; x < SIZE; x++)
 	{
-                FPRINTF(stdout, "[%d] ", rank);
-                for (y = 0; y < SIZE; y++) {
-                        FPRINTF(stdout, "%3u ", matrix[x+y*SIZE]);
-                }
-                FPRINTF(stdout, "\n");
-        }
+		FPRINTF(stdout, "[%d] ", rank);
+		for (y = 0; y < SIZE; y++)
+		{
+			FPRINTF(stdout, "%3u ", matrix[x+y*SIZE]);
+		}
+		FPRINTF(stdout, "\n");
+	}
 #endif
 
 	return 0;

mpi/tests/insert_task_cache.c

@@ -35,7 +35,7 @@ struct starpu_codelet mycodelet =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_RW, STARPU_R}
 };
 
@@ -44,15 +44,15 @@ struct starpu_codelet mycodelet =
 /* Returns the MPI node number where data indexes index is */
 int my_distrib(int x)
 {
-        return x;
+	return x;
 }
 
 void test_cache(int rank, int size, int enabled, size_t *comm_amount)
 {
-        int i;
-        int ret;
+	int i;
+	int ret;
 	unsigned v[2][N];
-        starpu_data_handle_t data_handles[2];
+	starpu_data_handle_t data_handles[2];
 	char *string;
 
 	string = malloc(50);
@@ -64,7 +64,7 @@ void test_cache(int rank, int size, int enabled, size_t *comm_amount)
 	ret = starpu_mpi_init(NULL, NULL, 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
 
-        for(i = 0; i < 2; i++)
+	for(i = 0; i < 2; i++)
 	{
 		int mpi_rank = my_distrib(i);
 		if (mpi_rank == rank)
@@ -80,26 +80,26 @@ void test_cache(int rank, int size, int enabled, size_t *comm_amount)
 		}
 		starpu_data_set_rank(data_handles[i], mpi_rank);
 		starpu_data_set_tag(data_handles[i], i);
-        }
+	}
 
-        for(i = 0; i < 5; i++)
+	for(i = 0; i < 5; i++)
 	{
 		ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[0], STARPU_R, data_handles[1], 0);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
 	}
 
-        for(i = 0; i < 5; i++)
+	for(i = 0; i < 5; i++)
 	{
 		ret = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet, STARPU_RW, data_handles[1], STARPU_R, data_handles[0], 0);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_insert_task");
 	}
 
-        starpu_task_wait_for_all();
+	starpu_task_wait_for_all();
 
-        for(i = 0; i < 2; i++)
+	for(i = 0; i < 2; i++)
 	{
 		starpu_data_unregister(data_handles[i]);
-        }
+	}
 
 	starpu_mpi_comm_amounts_retrieve(comm_amount);
 	starpu_mpi_shutdown();

mpi/tests/insert_task_owner.c

@@ -23,7 +23,7 @@ void func_cpu(void *descr[], __attribute__ ((unused)) void *_args)
 	int node;
 	int rank;
 
-        starpu_codelet_unpack_args(_args, &node);
+	starpu_codelet_unpack_args(_args, &node);
 	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 	FPRINTF(stderr, "Expected node: %d - Actual node: %d\n", node, rank);
 
@@ -34,7 +34,7 @@ struct starpu_codelet mycodelet_r_w =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_R, STARPU_W}
 };
 
@@ -42,7 +42,7 @@ struct starpu_codelet mycodelet_rw_r =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_RW, STARPU_R}
 };
 
@@ -50,7 +50,7 @@ struct starpu_codelet mycodelet_rw_rw =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_RW, STARPU_RW}
 };
 
@@ -58,7 +58,7 @@ struct starpu_codelet mycodelet_w_r =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_W, STARPU_R}
 };
 
@@ -66,16 +66,16 @@ struct starpu_codelet mycodelet_r_r =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_R, STARPU_R}
 };
 
 int main(int argc, char **argv)
 {
-        int ret, rank, size, err, node;
-        int x0=32, x1=23;
-        starpu_data_handle_t data_handlesx0;
-        starpu_data_handle_t data_handlesx1;
+	int ret, rank, size, err, node;
+	int x0=32, x1=23;
+	starpu_data_handle_t data_handlesx0;
+	starpu_data_handle_t data_handlesx1;
 
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -86,88 +86,88 @@ int main(int argc, char **argv)
 
 	if (rank != 0 && rank != 1) goto end;
 
-        if (rank == 0)
+	if (rank == 0)
 	{
-                starpu_variable_data_register(&data_handlesx0, 0, (uintptr_t)&x0, sizeof(x0));
-                starpu_data_set_rank(data_handlesx0, rank);
+		starpu_variable_data_register(&data_handlesx0, 0, (uintptr_t)&x0, sizeof(x0));
+		starpu_data_set_rank(data_handlesx0, rank);
 		starpu_data_set_tag(data_handlesx0, 0);
-                starpu_variable_data_register(&data_handlesx1, -1, (uintptr_t)NULL, sizeof(int));
-                starpu_data_set_rank(data_handlesx1, 1);
+		starpu_variable_data_register(&data_handlesx1, -1, (uintptr_t)NULL, sizeof(int));
+		starpu_data_set_rank(data_handlesx1, 1);
 		starpu_data_set_tag(data_handlesx1, 1);
-        }
-        else if (rank == 1)
+	}
+	else if (rank == 1)
 	{
-                starpu_variable_data_register(&data_handlesx1, 0, (uintptr_t)&x1, sizeof(x1));
-                starpu_data_set_rank(data_handlesx1, rank);
+		starpu_variable_data_register(&data_handlesx1, 0, (uintptr_t)&x1, sizeof(x1));
+		starpu_data_set_rank(data_handlesx1, rank);
 		starpu_data_set_tag(data_handlesx1, 1);
-                starpu_variable_data_register(&data_handlesx0, -1, (uintptr_t)NULL, sizeof(int));
-                starpu_data_set_rank(data_handlesx0, 0);
+		starpu_variable_data_register(&data_handlesx0, -1, (uintptr_t)NULL, sizeof(int));
+		starpu_data_set_rank(data_handlesx0, 0);
 		starpu_data_set_tag(data_handlesx0, 0);
-        }
+	}
 
 	node = starpu_data_get_rank(data_handlesx1);
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_w,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_w,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_R, data_handlesx0, STARPU_W, data_handlesx1,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
 	node = starpu_data_get_rank(data_handlesx0);
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_r,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_r,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_RW, data_handlesx0, STARPU_R, data_handlesx1,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_RW, data_handlesx0, STARPU_RW, data_handlesx1,
 				     0);
-        assert(err == -EINVAL);
+	assert(err == -EINVAL);
 
 	node = 1;
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_RW, data_handlesx0, STARPU_RW, data_handlesx1, STARPU_EXECUTE_ON_NODE, node,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
 	node = 0;
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_rw_rw,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_RW, data_handlesx0, STARPU_RW, data_handlesx1, STARPU_EXECUTE_ON_NODE, node,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
 	node = 0;
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_r,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_r,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_R, data_handlesx0, STARPU_R, data_handlesx1, STARPU_EXECUTE_ON_NODE, node,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
-        /* Here the value specified by the property STARPU_EXECUTE_ON_NODE is
-           going to overwrite the node even though the data model clearly specifies
-           which node is going to execute the codelet */
+	/* Here the value specified by the property STARPU_EXECUTE_ON_NODE is
+	   going to overwrite the node even though the data model clearly specifies
+	   which node is going to execute the codelet */
 	node = 0;
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_w,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_r_w,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_R, data_handlesx0, STARPU_W, data_handlesx1, STARPU_EXECUTE_ON_NODE, node,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
-        /* Here the value specified by the property STARPU_EXECUTE_ON_NODE is
-           going to overwrite the node even though the data model clearly specifies
-           which node is going to execute the codelet */
+	/* Here the value specified by the property STARPU_EXECUTE_ON_NODE is
+	   going to overwrite the node even though the data model clearly specifies
+	   which node is going to execute the codelet */
 	node = 0;
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_w_r,
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet_w_r,
 				     STARPU_VALUE, &node, sizeof(node),
 				     STARPU_W, data_handlesx0, STARPU_R, data_handlesx1, STARPU_EXECUTE_ON_NODE, node,
 				     0);
-        assert(err == 0);
+	assert(err == 0);
 
 	fprintf(stderr, "Waiting ...\n");
-        starpu_task_wait_for_all();
+	starpu_task_wait_for_all();
 	starpu_data_unregister(data_handlesx0);
 	starpu_data_unregister(data_handlesx1);
 

mpi/tests/insert_task_owner2.c

@@ -25,33 +25,32 @@ void func_cpu(void *descr[], __attribute__ ((unused)) void *_args)
 	int *x2 = (int *)STARPU_VARIABLE_GET_PTR(descr[2]);
 	int *y = (int *)STARPU_VARIABLE_GET_PTR(descr[3]);
 
-//        FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
-//
-//        *x2 = 45;
-//        *y = 144;
-//
-        FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
-        *y = (*x0 + *x1) * 100;
-        *x1 = 12;
-        *x2 = 24;
-        *x0 = 36;
-        FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
+	//FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
+	//*x2 = 45;
+	//*y = 144;
+
+	FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
+	*y = (*x0 + *x1) * 100;
+	*x1 = 12;
+	*x2 = 24;
+	*x0 = 36;
+	FPRINTF(stderr, "-------> CODELET VALUES: %d %d %d %d\n", *x0, *x1, *x2, *y);
 }
 
 struct starpu_codelet mycodelet =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 4,
+	.nbuffers = 4,
 	.modes = {STARPU_R, STARPU_RW, STARPU_W, STARPU_W}
 };
 
 int main(int argc, char **argv)
 {
-        int rank, size, err;
-        int x[3], y=0;
-        int i, ret;
-        starpu_data_handle_t data_handles[4];
+	int rank, size, err;
+	int x[3], y=0;
+	int i, ret;
+	starpu_data_handle_t data_handles[4];
 
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -60,31 +59,32 @@ int main(int argc, char **argv)
 	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 	MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-        if (rank == 0)
+	if (rank == 0)
 	{
-                for(i=0 ; i<3 ; i++)
+		for(i=0 ; i<3 ; i++)
 		{
-                        x[i] = 10*(i+1);
-                        starpu_variable_data_register(&data_handles[i], 0, (uintptr_t)&x[i], sizeof(x[i]));
-                }
-                y = -1;
-                starpu_variable_data_register(&data_handles[3], -1, (uintptr_t)NULL, sizeof(int));
-        }
-        else if (rank == 1)
+			x[i] = 10*(i+1);
+			starpu_variable_data_register(&data_handles[i], 0, (uintptr_t)&x[i], sizeof(x[i]));
+		}
+		y = -1;
+		starpu_variable_data_register(&data_handles[3], -1, (uintptr_t)NULL, sizeof(int));
+	}
+	else if (rank == 1)
 	{
-                for(i=0 ; i<3 ; i++)
+		for(i=0 ; i<3 ; i++)
 		{
-                        x[i] = -1;
-                        starpu_variable_data_register(&data_handles[i], -1, (uintptr_t)NULL, sizeof(int));
-                }
-                y=200;
-                starpu_variable_data_register(&data_handles[3], 0, (uintptr_t)&y, sizeof(int));
-        } else
+			x[i] = -1;
+			starpu_variable_data_register(&data_handles[i], -1, (uintptr_t)NULL, sizeof(int));
+		}
+		y=200;
+		starpu_variable_data_register(&data_handles[3], 0, (uintptr_t)&y, sizeof(int));
+	}
+	else
 	{
-                for(i=0 ; i<4 ; i++)
-                        starpu_variable_data_register(&data_handles[i], -1, (uintptr_t)NULL, sizeof(int));
+		for(i=0 ; i<4 ; i++)
+			starpu_variable_data_register(&data_handles[i], -1, (uintptr_t)NULL, sizeof(int));
 	}
-        FPRINTF(stderr, "[%d][init] VALUES: %d %d %d %d\n", rank, x[0], x[1], x[2], y);
+	FPRINTF(stderr, "[%d][init] VALUES: %d %d %d %d\n", rank, x[0], x[1], x[2], y);
 
 	for(i=0 ; i<3 ; i++)
 	{
@@ -94,23 +94,24 @@ int main(int argc, char **argv)
 	starpu_data_set_rank(data_handles[3], 1);
 	starpu_data_set_tag(data_handles[3], 3);
 
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
-                                     STARPU_R, data_handles[0], STARPU_RW, data_handles[1],
-                                     STARPU_W, data_handles[2],
-                                     STARPU_W, data_handles[3],
-                                     STARPU_EXECUTE_ON_NODE, 1, 0);
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
+				     STARPU_R, data_handles[0], STARPU_RW, data_handles[1],
+				     STARPU_W, data_handles[2],
+				     STARPU_W, data_handles[3],
+				     STARPU_EXECUTE_ON_NODE, 1, 0);
 	STARPU_CHECK_RETURN_VALUE(err, "starpu_mpi_insert_task");
-        starpu_task_wait_for_all();
+	starpu_task_wait_for_all();
 
-        int *values = malloc(4 * sizeof(int *));
-        for(i=0 ; i<4 ; i++)
+	int *values = malloc(4 * sizeof(int *));
+	for(i=0 ; i<4 ; i++)
 	{
-                starpu_mpi_get_data_on_node_detached(MPI_COMM_WORLD, data_handles[i], 0, NULL, NULL);
-		if (rank == 0) {
+		starpu_mpi_get_data_on_node_detached(MPI_COMM_WORLD, data_handles[i], 0, NULL, NULL);
+		if (rank == 0)
+		{
 			starpu_data_acquire(data_handles[i], STARPU_R);
 			values[i] = *((int *)starpu_handle_get_local_ptr(data_handles[i]));
 		}
-        }
+	}
         FPRINTF(stderr, "[%d][local ptr] VALUES: %d %d %d %d\n", rank, values[0], values[1], values[2], values[3]);
         FPRINTF(stderr, "[%d][end] VALUES: %d %d %d %d\n", rank, x[0], x[1], x[2], y);
 

mpi/tests/insert_task_owner_data.c

@@ -31,16 +31,16 @@ struct starpu_codelet mycodelet =
 {
 	.where = STARPU_CPU,
 	.cpu_funcs = {func_cpu, NULL},
-        .nbuffers = 2,
+	.nbuffers = 2,
 	.modes = {STARPU_RW, STARPU_RW}
 };
 
 int main(int argc, char **argv)
 {
-        int rank, size, err;
-        int x[2];
-        int ret, i;
-        starpu_data_handle_t data_handles[2];
+	int rank, size, err;
+	int x[2];
+	int ret, i;
+	starpu_data_handle_t data_handles[2];
 	int values[2];
 
 	ret = starpu_init(NULL);
@@ -50,46 +50,47 @@ int main(int argc, char **argv)
 	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 	MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-        if (rank == 0)
+	if (rank == 0)
 	{
 		x[0] = 11;
 		starpu_variable_data_register(&data_handles[0], 0, (uintptr_t)&x[0], sizeof(x[0]));
 		starpu_variable_data_register(&data_handles[1], -1, (uintptr_t)NULL, sizeof(x[1]));
-        }
-        else if (rank == 1)
+	}
+	else if (rank == 1)
 	{
 		x[1] = 12;
 		starpu_variable_data_register(&data_handles[0], -1, (uintptr_t)NULL, sizeof(x[0]));
 		starpu_variable_data_register(&data_handles[1], 0, (uintptr_t)&x[1], sizeof(x[1]));
-        }
+	}
 	else
 	{
 		starpu_variable_data_register(&data_handles[0], -1, (uintptr_t)NULL, sizeof(x[0]));
 		starpu_variable_data_register(&data_handles[1], -1, (uintptr_t)NULL, sizeof(x[1]));
-        }
+	}
 
 	starpu_data_set_rank(data_handles[0], 0);
 	starpu_data_set_tag(data_handles[0], 0);
 	starpu_data_set_rank(data_handles[1], 1);
 	starpu_data_set_tag(data_handles[1], 1);
 
-        err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
-                                     STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
-                                     STARPU_EXECUTE_ON_DATA, data_handles[1],
+	err = starpu_mpi_insert_task(MPI_COMM_WORLD, &mycodelet,
+				     STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
+				     STARPU_EXECUTE_ON_DATA, data_handles[1],
 				     0);
-        assert(err == 0);
-        starpu_task_wait_for_all();
+	assert(err == 0);
+	starpu_task_wait_for_all();
 
-        for(i=0 ; i<2 ; i++)
+	for(i=0 ; i<2 ; i++)
 	{
-                starpu_mpi_get_data_on_node_detached(MPI_COMM_WORLD, data_handles[i], 0, NULL, NULL);
-		if (rank == 0) {
+		starpu_mpi_get_data_on_node_detached(MPI_COMM_WORLD, data_handles[i], 0, NULL, NULL);
+		if (rank == 0)
+		{
 			starpu_data_acquire(data_handles[i], STARPU_R);
 			values[i] = *((int *)starpu_handle_get_local_ptr(data_handles[i]));
 			starpu_data_release(data_handles[i]);
 		}
-        }
-        FPRINTF(stderr, "[%d][local ptr] VALUES: %d %d\n", rank, values[0], values[1]);
+	}
+	FPRINTF(stderr, "[%d][local ptr] VALUES: %d %d\n", rank, values[0], values[1]);
 	ret = 0;
 	if (rank == 0 && (values[0] != 12 || values[1] != 144))
 		ret = EXIT_FAILURE;

mpi/tests/mpi_reduction.c

@@ -65,9 +65,9 @@ int my_distrib(int x, int nb_nodes)
 int main(int argc, char **argv)
 {
 	int my_rank, size, x, y, i;
-        long int *vector;
+	long int *vector;
 	long int dot, sum=0;
-        starpu_data_handle_t *handles;
+	starpu_data_handle_t *handles;
 	starpu_data_handle_t dot_handle;
 
 	int nb_elements, step, loops;
@@ -84,7 +84,7 @@ int main(int argc, char **argv)
 	loops = 5;
 
 	vector = (long int *) malloc(nb_elements*sizeof(vector[0]));
-        for(x = 0; x < nb_elements; x+=step)
+	for(x = 0; x < nb_elements; x+=step)
 	{
 		int mpi_rank = my_distrib(x/step, size);
 		if (mpi_rank == my_rank)
@@ -94,7 +94,7 @@ int main(int argc, char **argv)
 				vector[x+y] = x+y+1;
 			}
 		}
-        }
+	}
 	if (my_rank == 0) {
 		dot = 14;
 		sum = (nb_elements * (nb_elements + 1)) / 2;
@@ -109,7 +109,7 @@ int main(int argc, char **argv)
 
 
 	handles = (starpu_data_handle_t *) malloc(nb_elements*sizeof(handles[0]));
-        for(x = 0; x < nb_elements; x+=step)
+	for(x = 0; x < nb_elements; x+=step)
 	{
 		int mpi_rank = my_distrib(x/step, size);
 		if (mpi_rank == my_rank)
@@ -146,10 +146,10 @@ int main(int argc, char **argv)
 		starpu_mpi_insert_task(MPI_COMM_WORLD, &display_codelet, STARPU_R, dot_handle, 0);
 	}
 
-        fprintf(stderr, "Waiting ...\n");
-        starpu_task_wait_for_all();
+	fprintf(stderr, "Waiting ...\n");
+	starpu_task_wait_for_all();
 
-        for(x = 0; x < nb_elements; x+=step)
+	for(x = 0; x < nb_elements; x+=step)
 	{
 		if (handles[x]) starpu_data_unregister(handles[x]);
 	}
@@ -165,10 +165,10 @@ int main(int argc, char **argv)
 
 	if (my_rank == 0)
 	{
-                fprintf(stderr, "[%d] sum=%ld\n", my_rank, sum);
-                fprintf(stderr, "[%d] dot=%ld\n", my_rank, dot);
+		fprintf(stderr, "[%d] sum=%ld\n", my_rank, sum);
+		fprintf(stderr, "[%d] dot=%ld\n", my_rank, dot);
 		fprintf(stderr, "%s when computing reduction\n", (sum == dot) ? "Success" : "Error");
-        }
+	}
 
 	return 0;
 }

mpi/tests/mpi_scatter_gather.c

@@ -19,7 +19,7 @@
 /* Returns the MPI node number where data indexes index is */
 int my_distrib(int x, int y, int nb_nodes)
 {
-        return (x+y) % nb_nodes;
+	return (x+y) % nb_nodes;
 }
 
 void cpu_codelet(void *descr[], void *_args)
@@ -32,7 +32,7 @@ void cpu_codelet(void *descr[], void *_args)
 	float factor;
 
 	block = (float *)STARPU_MATRIX_GET_PTR(descr[0]);
-        starpu_codelet_unpack_args(_args, &rank);
+	starpu_codelet_unpack_args(_args, &rank);
 	factor = block[0];
 
 	//fprintf(stderr,"rank %d factor %f\n", rank, factor);
@@ -68,9 +68,9 @@ void rcallback(void *arg __attribute__((unused)))
 
 int main(int argc, char **argv)
 {
-        int rank, nodes;
+	int rank, nodes;
 	float ***bmat = NULL;
-        starpu_data_handle_t *data_handles;
+	starpu_data_handle_t *data_handles;
 
 	unsigned i,j,x,y;
 
@@ -135,10 +135,10 @@ int main(int argc, char **argv)
 #endif
 
 	/* Allocate data handles and register data to StarPU */
-        data_handles = malloc(nblocks*nblocks*sizeof(starpu_data_handle_t *));
-        for(x = 0; x < nblocks ;  x++)
+	data_handles = malloc(nblocks*nblocks*sizeof(starpu_data_handle_t *));
+	for(x = 0; x < nblocks ; x++)
 	{
-                for (y = 0; y < nblocks; y++)
+		for (y = 0; y < nblocks; y++)
 		{
 			int mpi_rank = my_distrib(x, y, nodes);
 			if (rank == 0)
@@ -158,19 +158,19 @@ int main(int argc, char **argv)
 				/* I know it's useless to allocate anything for this */
 				data_handles[x+y*nblocks] = NULL;
 			}
-                        if (data_handles[x+y*nblocks])
+			if (data_handles[x+y*nblocks])
 			{
-                                starpu_data_set_rank(data_handles[x+y*nblocks], mpi_rank);
-                                starpu_data_set_tag(data_handles[x+y*nblocks], (y*nblocks)+x);
+				starpu_data_set_rank(data_handles[x+y*nblocks], mpi_rank);
+				starpu_data_set_tag(data_handles[x+y*nblocks], (y*nblocks)+x);
 			}
-                }
-        }
+		}
+	}
 
 	/* Scatter the matrix among the nodes */
 	starpu_mpi_scatter_detached(data_handles, nblocks*nblocks, 0, MPI_COMM_WORLD, scallback, "scatter", NULL, NULL);
 
 	/* Calculation */
-	for(x = 0; x < nblocks*nblocks ;  x++)
+	for(x = 0; x < nblocks*nblocks ; x++)
 	{
 		if (data_handles[x])
 		{
@@ -222,7 +222,7 @@ int main(int argc, char **argv)
 #endif
 
 	// Free memory
-        free(data_handles);
+	free(data_handles);
 	if (rank == 0)
 	{
 		for(x=0 ; x<nblocks ; x++)

mpi/tests/mpi_test.c

@@ -60,7 +60,7 @@ int main(int argc, char **argv)
 
 		if ((loop % 2) == (rank%2))
 		{
-                        starpu_mpi_isend(tab_handle, &req, other_rank, loop, MPI_COMM_WORLD);
+			starpu_mpi_isend(tab_handle, &req, other_rank, loop, MPI_COMM_WORLD);
 		}
 		else
 		{

mpi/tests/multiple_send.c

@@ -22,11 +22,11 @@
 int main(int argc, char **argv)
 {
 	int ret, rank, size;
-        unsigned send[2] = {42, 11};
-        unsigned recv[2] = {33, 33};
-        starpu_mpi_req req[2];
-        starpu_data_handle_t send_handle[2];
-        starpu_data_handle_t recv_handle[2];
+	unsigned send[2] = {42, 11};
+	unsigned recv[2] = {33, 33};
+	starpu_mpi_req req[2];
+	starpu_data_handle_t send_handle[2];
+	starpu_data_handle_t recv_handle[2];
 
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -40,8 +40,8 @@ int main(int argc, char **argv)
 		if (rank == 0)
 			FPRINTF(stderr, "We need at least 2 processes.\n");
 
-                starpu_mpi_shutdown();
-                starpu_shutdown();
+		starpu_mpi_shutdown();
+		starpu_shutdown();
 		return STARPU_TEST_SKIPPED;
 	}
 
@@ -50,42 +50,42 @@ int main(int argc, char **argv)
 	starpu_variable_data_register(&recv_handle[0], 0, (uintptr_t)&recv[0], sizeof(unsigned));
 	starpu_variable_data_register(&recv_handle[1], 0, (uintptr_t)&recv[1], sizeof(unsigned));
 
-        if (rank == 0)
+	if (rank == 0)
 	{
-                starpu_mpi_isend(send_handle[0], &(req[0]), 1, 12, MPI_COMM_WORLD);
-                starpu_mpi_isend(send_handle[1], &(req[1]), 1, 13, MPI_COMM_WORLD);
-        }
-        else if (rank == 1)
+		starpu_mpi_isend(send_handle[0], &(req[0]), 1, 12, MPI_COMM_WORLD);
+		starpu_mpi_isend(send_handle[1], &(req[1]), 1, 13, MPI_COMM_WORLD);
+	}
+	else if (rank == 1)
 	{
-                starpu_mpi_irecv(recv_handle[0], &(req[0]), 0, 12, MPI_COMM_WORLD);
-                starpu_mpi_irecv(recv_handle[1], &(req[1]), 0, 13, MPI_COMM_WORLD);
-        }
+		starpu_mpi_irecv(recv_handle[0], &(req[0]), 0, 12, MPI_COMM_WORLD);
+		starpu_mpi_irecv(recv_handle[1], &(req[1]), 0, 13, MPI_COMM_WORLD);
+	}
 
-        if (rank == 0 || rank == 1)
+	if (rank == 0 || rank == 1)
 	{
-                int nb_req=2;
-                while (nb_req)
+		int nb_req=2;
+		while (nb_req)
 		{
-                        int r=0;
-                        for(r=0 ; r<2 ; r++)
+			int r=0;
+			for(r=0 ; r<2 ; r++)
 			{
-                                if (req[r])
+				if (req[r])
 				{
-                                        int finished = 0;
-                                        MPI_Status status;
-                                        starpu_mpi_test(&req[r], &finished, &status);
-                                        STARPU_ASSERT(finished != -1);
-                                        if (finished)
+					int finished = 0;
+					MPI_Status status;
+					starpu_mpi_test(&req[r], &finished, &status);
+					STARPU_ASSERT(finished != -1);
+					if (finished)
 					{
-                                                FPRINTF(stderr, "[%d] Request %d finished\n", rank, r);
-                                                req[r] = NULL;
-                                                nb_req--;
-                                        }
-                                }
-                        }
-                }
-        }
-        FPRINTF(stderr, "[%d] All requests finished\n", rank);
+						FPRINTF(stderr, "[%d] Request %d finished\n", rank, r);
+						req[r] = NULL;
+						nb_req--;
+					}
+				}
+			}
+		}
+	}
+	FPRINTF(stderr, "[%d] All requests finished\n", rank);
 
 	starpu_data_unregister(send_handle[0]);
 	starpu_data_unregister(send_handle[1]);

mpi/tests/ring_async_implicit.c

@@ -124,8 +124,8 @@ int main(int argc, char **argv)
 
 	if (rank == last_rank)
 	{
-                FPRINTF(stderr, "[%d] token = %u == %u * %d ?\n", rank, token, nloops, size);
-                STARPU_ASSERT(token == nloops*size);
+		FPRINTF(stderr, "[%d] token = %u == %u * %d ?\n", rank, token, nloops, size);
+		STARPU_ASSERT(token == nloops*size);
 	}
 
 	return 0;