Fix -Wshadow warnings, enable it by default

configure.ac

@@ -2261,10 +2261,10 @@ IS_SUPPORTED_FLAG(-Wextra)
 IS_SUPPORTED_FLAG(-Wunused)
 IS_SUPPORTED_CFLAG(-Wundef)
 IS_SUPPORTED_CXXFLAG(-Wundef)
+IS_SUPPORTED_FLAG(-Wshadow)
 
 if test "x$STARPU_DEVEL" != x; then
 	AC_DEFINE(STARPU_DEVEL, [1], [enable developer warnings])
-	IS_SUPPORTED_FLAG(-Wshadow)
 	IS_SUPPORTED_CFLAG(-Werror=pointer-arith)
 	IS_SUPPORTED_CXXFLAG(-Werror=pointer-arith)
 	IS_SUPPORTED_FLAG(-fno-common)

examples/cg/cg.c

@@ -79,12 +79,12 @@ static int copy_handle(starpu_data_handle_t dst, starpu_data_handle_t src, unsig
 static TYPE *A, *b, *x;
 static TYPE *r, *d, *q;
 
-static int copy_handle(starpu_data_handle_t dst, starpu_data_handle_t src, unsigned nblocks)
+static int copy_handle(starpu_data_handle_t dst, starpu_data_handle_t src, unsigned nb)
 {
-	unsigned b;
+	unsigned block;
 
-	for (b = 0; b < nblocks; b++)
-		starpu_data_cpy(starpu_data_get_sub_data(dst, 1, b), starpu_data_get_sub_data(src, 1, b), 1, NULL, NULL);
+	for (block = 0; block < nb; block++)
+		starpu_data_cpy(starpu_data_get_sub_data(dst, 1, block), starpu_data_get_sub_data(src, 1, block), 1, NULL, NULL);
 	return 0;
 }
 

examples/cg/cg_kernels.c

@@ -164,9 +164,9 @@ static void accumulate_vector_cuda(void *descr[], void *cl_arg)
 	(void)cl_arg;
 	TYPE *v_dst = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
 	TYPE *v_src = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
-	cublasStatus_t status = cublasaxpy(starpu_cublas_get_local_handle(), n, &gp1, v_src, 1, v_dst, 1);
+	cublasStatus_t status = cublasaxpy(starpu_cublas_get_local_handle(), nx, &gp1, v_src, 1, v_dst, 1);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
 }
@@ -177,9 +177,9 @@ void accumulate_vector_cpu(void *descr[], void *cl_arg)
 	(void)cl_arg;
 	TYPE *v_dst = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
 	TYPE *v_src = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
-	AXPY(n, (TYPE)1.0, v_src, 1, v_dst, 1);
+	AXPY(nx, (TYPE)1.0, v_src, 1, v_dst, 1);
 }
 
 static struct starpu_perfmodel accumulate_vector_model =
@@ -253,10 +253,10 @@ static void bzero_vector_cuda(void *descr[], void *cl_arg)
 {
 	(void)cl_arg;
 	TYPE *v = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 	size_t elemsize = STARPU_VECTOR_GET_ELEMSIZE(descr[0]);
 
-	cudaMemsetAsync(v, 0, n * elemsize, starpu_cuda_get_local_stream());
+	cudaMemsetAsync(v, 0, nx * elemsize, starpu_cuda_get_local_stream());
 }
 #endif
 
@@ -264,9 +264,9 @@ void bzero_vector_cpu(void *descr[], void *cl_arg)
 {
 	(void)cl_arg;
 	TYPE *v = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
-	memset(v, 0, n*sizeof(TYPE));
+	memset(v, 0, nx*sizeof(TYPE));
 }
 
 static struct starpu_perfmodel bzero_vector_model =
@@ -302,12 +302,12 @@ static void dot_kernel_cuda(void *descr[], void *cl_arg)
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
 	TYPE *v2 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[2]);
 
-	unsigned n = STARPU_VECTOR_GET_NX(descr[1]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[1]);
 
 	cublasHandle_t handle = starpu_cublas_get_local_handle();
 	cublasSetPointerMode(handle, CUBLAS_POINTER_MODE_DEVICE);
 	cublasStatus_t status = cublasdot(handle,
-		n, v1, 1, v2, 1, dot);
+		nx, v1, 1, v2, 1, dot);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
 	cublasSetPointerMode(handle, CUBLAS_POINTER_MODE_HOST);
@@ -321,12 +321,12 @@ void dot_kernel_cpu(void *descr[], void *cl_arg)
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
 	TYPE *v2 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[2]);
 
-	unsigned n = STARPU_VECTOR_GET_NX(descr[1]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[1]);
 
 	TYPE local_dot;
 	/* Note that we explicitely cast the result of the DOT kernel because
 	 * some BLAS library will return a double for sdot for instance. */
-	local_dot = (TYPE)DOT(n, v1, 1, v2, 1);
+	local_dot = (TYPE)DOT(nx, v1, 1, v2, 1);
 
 	*dot = *dot + local_dot;
 }
@@ -354,7 +354,7 @@ static struct starpu_codelet dot_kernel_cl =
 int dot_kernel(HANDLE_TYPE_VECTOR v1,
 	       HANDLE_TYPE_VECTOR v2,
 	       starpu_data_handle_t s,
-	       unsigned nblocks)
+	       unsigned nb)
 {
 	int ret;
 
@@ -368,14 +368,14 @@ int dot_kernel(HANDLE_TYPE_VECTOR v1,
 		STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");
 	}
 
-	unsigned b;
-	for (b = 0; b < nblocks; b++)
+	unsigned block;
+	for (block = 0; block < nb; block++)
 	{
 		ret = TASK_INSERT(&dot_kernel_cl,
 					 use_reduction?STARPU_REDUX:STARPU_RW, s,
-					 STARPU_R, GET_VECTOR_BLOCK(v1, b),
-					 STARPU_R, GET_VECTOR_BLOCK(v2, b),
-					 STARPU_TAG_ONLY, (starpu_tag_t) b,
+					 STARPU_R, GET_VECTOR_BLOCK(v1, block),
+					 STARPU_R, GET_VECTOR_BLOCK(v2, block),
+					 STARPU_TAG_ONLY, (starpu_tag_t) block,
 					 0);
 		STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");
 	}
@@ -393,11 +393,11 @@ static void scal_kernel_cuda(void *descr[], void *cl_arg)
 	starpu_codelet_unpack_args(cl_arg, &p1);
 
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
 	/* v1 = p1 v1 */
 	TYPE alpha = p1;
-	cublasStatus_t status = cublasscal(starpu_cublas_get_local_handle(), n, &alpha, v1, 1);
+	cublasStatus_t status = cublasscal(starpu_cublas_get_local_handle(), nx, &alpha, v1, 1);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
 }
@@ -409,10 +409,10 @@ void scal_kernel_cpu(void *descr[], void *cl_arg)
 	starpu_codelet_unpack_args(cl_arg, &alpha);
 
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
 	/* v1 = alpha v1 */
-	SCAL(n, alpha, v1, 1);
+	SCAL(nx, alpha, v1, 1);
 }
 
 static struct starpu_perfmodel scal_kernel_model =
@@ -479,14 +479,14 @@ void gemv_kernel_cpu(void *descr[], void *cl_arg)
 	if (worker_size > 1)
 	{
 		/* Parallel CPU task */
-		unsigned rank = starpu_combined_worker_get_rank();
+		unsigned i = starpu_combined_worker_get_rank();
 
-		unsigned block_size = (ny + worker_size - 1)/worker_size;
-		unsigned new_nx = STARPU_MIN(nx, block_size*(rank+1)) - block_size*rank;
+		unsigned bs = (ny + worker_size - 1)/worker_size;
+		unsigned new_nx = STARPU_MIN(nx, bs*(i+1)) - bs*i;
 
 		nx = new_nx;
-		v1 = &v1[block_size*rank];
-		M = &M[block_size*rank];
+		v1 = &v1[bs*i];
+		M = &M[bs*i];
 	}
 
 	/* Compute v1 = alpha M v2 + beta v1 */
@@ -519,12 +519,12 @@ int gemv_kernel(HANDLE_TYPE_VECTOR v1,
 		HANDLE_TYPE_MATRIX matrix,
 		HANDLE_TYPE_VECTOR v2,
 		TYPE p1, TYPE p2,
-		unsigned nblocks)
+		unsigned nb)
 {
 	unsigned b1, b2;
 	int ret;
 
-	for (b2 = 0; b2 < nblocks; b2++)
+	for (b2 = 0; b2 < nb; b2++)
 	{
 		ret = TASK_INSERT(&scal_kernel_cl,
 					 STARPU_RW, GET_VECTOR_BLOCK(v1, b2),
@@ -535,9 +535,9 @@ int gemv_kernel(HANDLE_TYPE_VECTOR v1,
 		STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");
 	}
 
-	for (b2 = 0; b2 < nblocks; b2++)
+	for (b2 = 0; b2 < nb; b2++)
 	{
-		for (b1 = 0; b1 < nblocks; b1++)
+		for (b1 = 0; b1 < nb; b1++)
 		{
 			TYPE one = 1.0;
 			ret = TASK_INSERT(&gemv_kernel_cl,
@@ -546,7 +546,7 @@ int gemv_kernel(HANDLE_TYPE_VECTOR v1,
 						 STARPU_R,	GET_VECTOR_BLOCK(v2, b1),
 						 STARPU_VALUE,	&one,	sizeof(one),
 						 STARPU_VALUE,	&p2,	sizeof(p2),
-						 STARPU_TAG_ONLY, ((starpu_tag_t)b2) * nblocks + b1,
+						 STARPU_TAG_ONLY, ((starpu_tag_t)b2) * nb + b1,
 						 0);
 			STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");
 		}
@@ -566,17 +566,17 @@ static void scal_axpy_kernel_cuda(void *descr[], void *cl_arg)
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
 	TYPE *v2 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
 
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
 	/* Compute v1 = p1 * v1 + p2 * v2.
 	 *	v1 = p1 v1
 	 *	v1 = v1 + p2 v2
 	 */
 	cublasStatus_t status;
-	status = cublasscal(starpu_cublas_get_local_handle(), n, &p1, v1, 1);
+	status = cublasscal(starpu_cublas_get_local_handle(), nx, &p1, v1, 1);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
-	status = cublasaxpy(starpu_cublas_get_local_handle(), n, &p2, v2, 1, v1, 1);
+	status = cublasaxpy(starpu_cublas_get_local_handle(), nx, &p2, v2, 1, v1, 1);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
 }
@@ -622,18 +622,18 @@ static struct starpu_codelet scal_axpy_kernel_cl =
 
 int scal_axpy_kernel(HANDLE_TYPE_VECTOR v1, TYPE p1,
 		     HANDLE_TYPE_VECTOR v2, TYPE p2,
-		     unsigned nblocks)
+		     unsigned nb)
 {
-	unsigned b;
-	for (b = 0; b < nblocks; b++)
+	unsigned block;
+	for (block = 0; block < nb; block++)
 	{
 		int ret;
 		ret = TASK_INSERT(&scal_axpy_kernel_cl,
-					 STARPU_RW, GET_VECTOR_BLOCK(v1, b),
-					 STARPU_R,  GET_VECTOR_BLOCK(v2, b),
+					 STARPU_RW, GET_VECTOR_BLOCK(v1, block),
+					 STARPU_R,  GET_VECTOR_BLOCK(v2, block),
 					 STARPU_VALUE, &p1, sizeof(p1),
 					 STARPU_VALUE, &p2, sizeof(p2),
-					 STARPU_TAG_ONLY, (starpu_tag_t) b,
+					 STARPU_TAG_ONLY, (starpu_tag_t) block,
 					 0);
 		if (ret == -ENODEV) return ret;
 		STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");
@@ -654,12 +654,12 @@ static void axpy_kernel_cuda(void *descr[], void *cl_arg)
 	TYPE *v1 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[0]);
 	TYPE *v2 = (TYPE *)STARPU_VECTOR_GET_PTR(descr[1]);
 
-	unsigned n = STARPU_VECTOR_GET_NX(descr[0]);
+	unsigned nx = STARPU_VECTOR_GET_NX(descr[0]);
 
 	/* Compute v1 = v1 + p1 * v2.
 	 */
 	cublasStatus_t status = cublasaxpy(starpu_cublas_get_local_handle(),
-			n, &p1, v2, 1, v1, 1);
+			nx, &p1, v2, 1, v1, 1);
 	if (status != CUBLAS_STATUS_SUCCESS)
 		STARPU_CUBLAS_REPORT_ERROR(status);
 }
@@ -702,17 +702,17 @@ static struct starpu_codelet axpy_kernel_cl =
 
 int axpy_kernel(HANDLE_TYPE_VECTOR v1,
 		HANDLE_TYPE_VECTOR v2, TYPE p1,
-		unsigned nblocks)
+		unsigned nb)
 {
-	unsigned b;
-	for (b = 0; b < nblocks; b++)
+	unsigned block;
+	for (block = 0; block < nb; block++)
 	{
 		int ret;
 		ret = TASK_INSERT(&axpy_kernel_cl,
-					 STARPU_RW, GET_VECTOR_BLOCK(v1, b),
-					 STARPU_R,  GET_VECTOR_BLOCK(v2, b),
+					 STARPU_RW, GET_VECTOR_BLOCK(v1, block),
+					 STARPU_R,  GET_VECTOR_BLOCK(v2, block),
 					 STARPU_VALUE, &p1, sizeof(p1),
-					 STARPU_TAG_ONLY, (starpu_tag_t) b,
+					 STARPU_TAG_ONLY, (starpu_tag_t) block,
 					 0);
 		if (ret == -ENODEV) return ret;
 		STARPU_CHECK_RETURN_VALUE(ret, "TASK_INSERT");

mpi/examples/cg/cg.c

@@ -57,20 +57,20 @@ static TYPE **q;
 
 #include "../../../examples/cg/cg_kernels.c"
 
-static int my_distrib(const int y, const int x)
+static int my_distrib(const int yy, const int xx)
 {
-	return (y%nodes_q)*nodes_p + (x%nodes_p);
+	return (yy%nodes_q)*nodes_p + (xx%nodes_p);
 }
 
-static int copy_handle(starpu_data_handle_t* dst, starpu_data_handle_t* src, unsigned nblocks)
+static int copy_handle(starpu_data_handle_t* dst, starpu_data_handle_t* src, unsigned nb)
 {
-	unsigned b;
+	unsigned block;
 
-	for (b = 0; b < nblocks; b++)
+	for (block = 0; block < nb; block++)
 	{
-		if (rank == my_distrib(b, 0))
+		if (rank == my_distrib(block, 0))
 		{
-			starpu_data_cpy(dst[b], src[b], /* asynchronous */ 1, /* without callback */ NULL, NULL);
+			starpu_data_cpy(dst[block], src[block], /* asynchronous */ 1, /* without callback */ NULL, NULL);
 		}
 	}
 
@@ -82,7 +82,7 @@ static int copy_handle(starpu_data_handle_t* dst, starpu_data_handle_t* src, uns
  */
 static void generate_random_problem(void)
 {
-	unsigned nn, mm, m, n;
+	unsigned ii, jj, j, i;
 	int mpi_rank;
 
 	A = malloc(nblocks * sizeof(TYPE **));
@@ -93,47 +93,47 @@ static void generate_random_problem(void)
 	d = malloc(nblocks * sizeof(TYPE *));
 	q = malloc(nblocks * sizeof(TYPE *));
 
-	for (m = 0; m < nblocks; m++)
+	for (j = 0; j < nblocks; j++)
 	{
-		A[m] = malloc(nblocks * sizeof(TYPE*));
+		A[j] = malloc(nblocks * sizeof(TYPE*));
 
-		mpi_rank = my_distrib(m, 0);
+		mpi_rank = my_distrib(j, 0);
 
 		if (mpi_rank == rank || display_result)
 		{
-			starpu_malloc((void**) &x[m], block_size*sizeof(TYPE));
+			starpu_malloc((void**) &x[j], block_size*sizeof(TYPE));
 		}
 
 		if (mpi_rank == rank)
 		{
-			starpu_malloc((void**) &b[m], block_size*sizeof(TYPE));
-			starpu_malloc((void**) &r[m], block_size*sizeof(TYPE));
-			starpu_malloc((void**) &d[m], block_size*sizeof(TYPE));
-			starpu_malloc((void**) &q[m], block_size*sizeof(TYPE));
+			starpu_malloc((void**) &b[j], block_size*sizeof(TYPE));
+			starpu_malloc((void**) &r[j], block_size*sizeof(TYPE));
+			starpu_malloc((void**) &d[j], block_size*sizeof(TYPE));
+			starpu_malloc((void**) &q[j], block_size*sizeof(TYPE));
 
-			for (mm = 0; mm < block_size; mm++)
+			for (jj = 0; jj < block_size; jj++)
 			{
-				x[m][mm] = (TYPE) 0.0;
-				b[m][mm] = (TYPE) 1.0;
-				r[m][mm] = (TYPE) 0.0;
-				d[m][mm] = (TYPE) 0.0;
-				q[m][mm] = (TYPE) 0.0;
+				x[j][jj] = (TYPE) 0.0;
+				b[j][jj] = (TYPE) 1.0;
+				r[j][jj] = (TYPE) 0.0;
+				d[j][jj] = (TYPE) 0.0;
+				q[j][jj] = (TYPE) 0.0;
 			}
 		}
 
-		for (n = 0; n < nblocks; n++)
+		for (i = 0; i < nblocks; i++)
 		{
-			mpi_rank = my_distrib(m, n);
+			mpi_rank = my_distrib(j, i);
 			if (mpi_rank == rank)
 			{
-				starpu_malloc((void**) &A[m][n], block_size*block_size*sizeof(TYPE));
+				starpu_malloc((void**) &A[j][i], block_size*block_size*sizeof(TYPE));
 
-				for (nn = 0; nn < block_size; nn++)
+				for (ii = 0; ii < block_size; ii++)
 				{
-					for (mm = 0; mm < block_size; mm++)
+					for (jj = 0; jj < block_size; jj++)
 					{
 						/* We take Hilbert matrix that is not well conditionned but definite positive: H(i,j) = 1/(1+i+j) */
-						A[m][n][mm + nn*block_size] = (TYPE) (1.0/(1.0+(nn+(m*block_size)+mm+(n*block_size))));
+						A[j][i][jj + ii*block_size] = (TYPE) (1.0/(1.0+(ii+(j*block_size)+jj+(i*block_size))));
 					}
 				}
 			}
@@ -143,36 +143,36 @@ static void generate_random_problem(void)
 
 static void free_data(void)
 {
-	unsigned nn, mm, m, n;
+	unsigned ii, jj, j, i;
 	int mpi_rank;
 
-	for (m = 0; m < nblocks; m++)
+	for (j = 0; j < nblocks; j++)
 	{
-		mpi_rank = my_distrib(m, 0);
+		mpi_rank = my_distrib(j, 0);
 
 		if (mpi_rank == rank || display_result)
 		{
-			starpu_free((void*) x[m]);
+			starpu_free((void*) x[j]);
 		}
 
 		if (mpi_rank == rank)
 		{
-			starpu_free((void*) b[m]);
-			starpu_free((void*) r[m]);
-			starpu_free((void*) d[m]);
-			starpu_free((void*) q[m]);
+			starpu_free((void*) b[j]);
+			starpu_free((void*) r[j]);
+			starpu_free((void*) d[j]);
+			starpu_free((void*) q[j]);
 		}
 
-		for (n = 0; n < nblocks; n++)
+		for (i = 0; i < nblocks; i++)
 		{
-			mpi_rank = my_distrib(m, n);
+			mpi_rank = my_distrib(j, i);
 			if (mpi_rank == rank)
 			{
-				starpu_free((void*) A[m][n]);
+				starpu_free((void*) A[j][i]);
 			}
 		}
 
-		free(A[m]);
+		free(A[j]);
 	}
 
 	free(A);
@@ -185,7 +185,7 @@ static void free_data(void)
 
 static void register_data(void)
 {
-	unsigned m, n;
+	unsigned j, i;
 	int mpi_rank;
 	starpu_mpi_tag_t mpi_tag = 0;
 
@@ -196,68 +196,68 @@ static void register_data(void)
 	d_handle = malloc(nblocks*sizeof(starpu_data_handle_t));
 	q_handle = malloc(nblocks*sizeof(starpu_data_handle_t));
 
-	for (m = 0; m < nblocks; m++)
+	for (j = 0; j < nblocks; j++)
 	{
-		mpi_rank = my_distrib(m, 0);
-		A_handle[m] = malloc(nblocks*sizeof(starpu_data_handle_t));
+		mpi_rank = my_distrib(j, 0);
+		A_handle[j] = malloc(nblocks*sizeof(starpu_data_handle_t));
 
 		if (mpi_rank == rank || display_result)
 		{
-			starpu_vector_data_register(&x_handle[m], STARPU_MAIN_RAM, (uintptr_t) x[m], block_size, sizeof(TYPE));
+			starpu_vector_data_register(&x_handle[j], STARPU_MAIN_RAM, (uintptr_t) x[j], block_size, sizeof(TYPE));
 		}
 		else if (!display_result)
 		{
 			assert(mpi_rank != rank);
-			starpu_vector_data_register(&x_handle[m], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
+			starpu_vector_data_register(&x_handle[j], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
 		}
 
 		if (mpi_rank == rank)
 		{
-			starpu_vector_data_register(&b_handle[m], STARPU_MAIN_RAM, (uintptr_t) b[m], block_size, sizeof(TYPE));
-			starpu_vector_data_register(&r_handle[m], STARPU_MAIN_RAM, (uintptr_t) r[m], block_size, sizeof(TYPE));
-			starpu_vector_data_register(&d_handle[m], STARPU_MAIN_RAM, (uintptr_t) d[m], block_size, sizeof(TYPE));
-			starpu_vector_data_register(&q_handle[m], STARPU_MAIN_RAM, (uintptr_t) q[m], block_size, sizeof(TYPE));
+			starpu_vector_data_register(&b_handle[j], STARPU_MAIN_RAM, (uintptr_t) b[j], block_size, sizeof(TYPE));
+			starpu_vector_data_register(&r_handle[j], STARPU_MAIN_RAM, (uintptr_t) r[j], block_size, sizeof(TYPE));
+			starpu_vector_data_register(&d_handle[j], STARPU_MAIN_RAM, (uintptr_t) d[j], block_size, sizeof(TYPE));
+			starpu_vector_data_register(&q_handle[j], STARPU_MAIN_RAM, (uintptr_t) q[j], block_size, sizeof(TYPE));
 		}
 		else
 		{
-			starpu_vector_data_register(&b_handle[m], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
-			starpu_vector_data_register(&r_handle[m], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
-			starpu_vector_data_register(&d_handle[m], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
-			starpu_vector_data_register(&q_handle[m], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
+			starpu_vector_data_register(&b_handle[j], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
+			starpu_vector_data_register(&r_handle[j], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
+			starpu_vector_data_register(&d_handle[j], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
+			starpu_vector_data_register(&q_handle[j], -1, (uintptr_t) NULL, block_size, sizeof(TYPE));
 		}
 
-		starpu_data_set_coordinates(x_handle[m], 1, m);
-		starpu_mpi_data_register(x_handle[m], ++mpi_tag, mpi_rank);
-		starpu_data_set_coordinates(b_handle[m], 1, m);
-		starpu_mpi_data_register(b_handle[m], ++mpi_tag, mpi_rank);
-		starpu_data_set_coordinates(r_handle[m], 1, m);
-		starpu_mpi_data_register(r_handle[m], ++mpi_tag, mpi_rank);
-		starpu_data_set_coordinates(d_handle[m], 1, m);
-		starpu_mpi_data_register(d_handle[m], ++mpi_tag, mpi_rank);
-		starpu_data_set_coordinates(q_handle[m], 1, m);
-		starpu_mpi_data_register(q_handle[m], ++mpi_tag, mpi_rank);
+		starpu_data_set_coordinates(x_handle[j], 1, j);
+		starpu_mpi_data_register(x_handle[j], ++mpi_tag, mpi_rank);
+		starpu_data_set_coordinates(b_handle[j], 1, j);
+		starpu_mpi_data_register(b_handle[j], ++mpi_tag, mpi_rank);
+		starpu_data_set_coordinates(r_handle[j], 1, j);
+		starpu_mpi_data_register(r_handle[j], ++mpi_tag, mpi_rank);
+		starpu_data_set_coordinates(d_handle[j], 1, j);
+		starpu_mpi_data_register(d_handle[j], ++mpi_tag, mpi_rank);
+		starpu_data_set_coordinates(q_handle[j], 1, j);
+		starpu_mpi_data_register(q_handle[j], ++mpi_tag, mpi_rank);
 
 		if (use_reduction)
 		{
-			starpu_data_set_reduction_methods(q_handle[m], &accumulate_vector_cl, &bzero_vector_cl);
-			starpu_data_set_reduction_methods(r_handle[m], &accumulate_vector_cl, &bzero_vector_cl);
+			starpu_data_set_reduction_methods(q_handle[j], &accumulate_vector_cl, &bzero_vector_cl);
+			starpu_data_set_reduction_methods(r_handle[j], &accumulate_vector_cl, &bzero_vector_cl);
 		}
 
-		for (n = 0; n < nblocks; n++)
+		for (i = 0; i < nblocks; i++)
 		{
-			mpi_rank = my_distrib(m, n);
+			mpi_rank = my_distrib(j, i);
 
 			if (mpi_rank == rank)
 			{
-				starpu_matrix_data_register(&A_handle[m][n], STARPU_MAIN_RAM, (uintptr_t) A[m][n], block_size, block_size, block_size, sizeof(TYPE));
+				starpu_matrix_data_register(&A_handle[j][i], STARPU_MAIN_RAM, (uintptr_t) A[j][i], block_size, block_size, block_size, sizeof(TYPE));
 			}
 			else
 			{
-				starpu_matrix_data_register(&A_handle[m][n], -1, (uintptr_t) NULL, block_size, block_size, block_size, sizeof(TYPE));
+				starpu_matrix_data_register(&A_handle[j][i], -1, (uintptr_t) NULL, block_size, block_size, block_size, sizeof(TYPE));
 			}
 
-			starpu_data_set_coordinates(A_handle[m][n], 2, n, m);
-			starpu_mpi_data_register(A_handle[m][n], ++mpi_tag, mpi_rank);
+			starpu_data_set_coordinates(A_handle[j][i], 2, i, j);
+			starpu_mpi_data_register(A_handle[j][i], ++mpi_tag, mpi_rank);
 		}
 	}
 
@@ -275,22 +275,22 @@ static void register_data(void)
 
 static void unregister_data(void)
 {
-	unsigned m, n;
+	unsigned j, i;
 
-	for (m = 0; m < nblocks; m++)
+	for (j = 0; j < nblocks; j++)
 	{
-		starpu_data_unregister(x_handle[m]);
-		starpu_data_unregister(b_handle[m]);
-		starpu_data_unregister(r_handle[m]);
-		starpu_data_unregister(d_handle[m]);
-		starpu_data_unregister(q_handle[m]);
+		starpu_data_unregister(x_handle[j]);
+		starpu_data_unregister(b_handle[j]);
+		starpu_data_unregister(r_handle[j]);
+		starpu_data_unregister(d_handle[j]);
+		starpu_data_unregister(q_handle[j]);
 
-		for (n = 0; n < nblocks; n++)
+		for (i = 0; i < nblocks; i++)
 		{
-			starpu_data_unregister(A_handle[m][n]);
+			starpu_data_unregister(A_handle[j][i]);
 		}
 
-		free(A_handle[m]);
+		free(A_handle[j]);
 	}
 
 	starpu_data_unregister(dtq_handle);

src/drivers/cuda/driver_cuda.c

@@ -106,12 +106,12 @@ static size_t _starpu_cuda_get_global_mem_size(unsigned devid)
 }
 
 #ifdef STARPU_HAVE_LIBNVIDIA_ML
-nvmlDevice_t _starpu_cuda_get_nvmldev(struct cudaDeviceProp *props)
+nvmlDevice_t _starpu_cuda_get_nvmldev(struct cudaDeviceProp *dev_props)
 {
 	char busid[13];
 	nvmlDevice_t ret;
 
-	snprintf(busid, sizeof(busid), "%04x:%02x:%02x.0", props->pciDomainID, props->pciBusID, props->pciDeviceID);
+	snprintf(busid, sizeof(busid), "%04x:%02x:%02x.0", dev_props->pciDomainID, dev_props->pciBusID, dev_props->pciDeviceID);
 	if (nvmlDeviceGetHandleByPciBusId(busid, &ret) != NVML_SUCCESS)
 		ret = NULL;