tests/datawizard: lower default for slow machines and indicate tests having memory leaks

tests/datawizard/acquire_cb_insert.c

@@ -18,6 +18,8 @@
 #include <starpu.h>
 #include "../helper.h"
 
+#warning memory leak
+
 #define N 16
 #define M 4
 #define X 2
@@ -117,18 +119,18 @@ int main(int argc, char **argv)
 	starpu_data_unregister(x_handle);
 
         FPRINTF(stderr, "VALUES: %d", x);
-
         for(i=0 ; i<N ; i++)
 	{
 		FPRINTF(stderr, " %f", f[i]);
         }
+	FPRINTF(stderr, "\n");
 
 	STARPU_ASSERT(f[X*(N/M)] == 1);
 	STARPU_ASSERT(f[X*(N/M)+1] == 2);
 	STARPU_ASSERT(f[X*(N/M)+2] == 3);
 	STARPU_ASSERT(f[X*(N/M)+3] == 4);
 
-	FPRINTF(stderr, "\n");
+	starpu_free(f);
 
 	starpu_shutdown();
 	return EXIT_SUCCESS;

tests/datawizard/acquire_release2.c

@@ -18,6 +18,8 @@
 #include <starpu.h>
 #include "../helper.h"
 
+#warning memory leak
+
 static unsigned ntasks = 40000;
 
 #ifdef STARPU_USE_CUDA

tests/datawizard/increment_redux.c

@@ -26,6 +26,7 @@
 #include <starpu_opencl.h>
 #endif
 
+#warning memory leak
 
 static unsigned var = 0;
 static starpu_data_handle_t handle;

tests/datawizard/increment_redux_lazy.c

@@ -25,6 +25,7 @@
 #include <starpu_opencl.h>
 #endif
 
+#warning memory leak
 
 static starpu_data_handle_t handle;
 

tests/datawizard/increment_redux_v2.c

@@ -25,6 +25,7 @@
 #include <starpu_opencl.h>
 #endif
 
+#warning memory leak
 
 static unsigned var = 0;
 static starpu_data_handle_t handle;

tests/datawizard/mpi_like.c

@@ -24,6 +24,8 @@
 #define NTHREADS	4
 #define NITER		128
 
+#warning memory leak
+
 //static pthread_cond_t cond;
 //static pthread_mutex_t mutex;
 

tests/datawizard/mpi_like_async.c

@@ -20,8 +20,13 @@
 #include <pthread.h>
 #include "../helper.h"
 
-#define NTHREADS	16
-#define NITER		128
+#define NTHREADS_DEFAULT	16
+#define NITER_DEFAULT		128
+
+static int nthreads = NTHREADS_DEFAULT;
+static int niter = NITER_DEFAULT;
+
+#warning memory leaks
 
 //#define DEBUG_MESSAGES	1
 
@@ -53,7 +58,7 @@ static pthread_cond_t data_req_cond;
 struct data_req *data_req_list;
 unsigned progress_thread_running;
 
-static struct thread_data problem_data[NTHREADS];
+static struct thread_data problem_data[NTHREADS_DEFAULT];
 
 /* We implement some ring transfer, every thread will try to receive a piece of
  * data from its neighbour and increment it before transmitting it to its
@@ -106,7 +111,7 @@ static int test_recv_handle_async(void *arg)
 
 	int ret;
 	struct thread_data *thread_data = (struct thread_data *) arg;
-	
+
 	_STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
 
 	ret = (thread_data->recv_flag == 1);
@@ -114,7 +119,7 @@ static int test_recv_handle_async(void *arg)
 	if (ret)
 	{
 		thread_data->recv_flag = 0;
-		thread_data->val = thread_data->recv_buf; 
+		thread_data->val = thread_data->recv_buf;
 	}
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
@@ -123,11 +128,11 @@ static int test_recv_handle_async(void *arg)
 	{
 #ifdef DEBUG_MESSAGES
 		FPRINTF(stderr, "Thread %d received value %d from thread %d\n",
-			thread_data->index, thread_data->val, (thread_data->index - 1)%NTHREADS);
+			thread_data->index, thread_data->val, (thread_data->index - 1)%nthreads);
 #endif
 		starpu_data_release(thread_data->handle);
 	}
-	
+
 	return ret;
 }
 
@@ -152,7 +157,7 @@ static int test_send_handle_async(void *arg)
 	int ret;
 	struct thread_data *thread_data = (struct thread_data *) arg;
 	struct thread_data *neighbour_data = thread_data->neighbour;
-	
+
 	_STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	ret = (neighbour_data->recv_flag == 0);
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
@@ -198,7 +203,7 @@ static void *progress_func(void *arg)
 	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 	progress_thread_running = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);	
+	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
 
 	while (progress_thread_running)
 	{
@@ -243,7 +248,7 @@ static void *progress_func(void *arg)
 							req_aux->next = req;
 							break;
 						}
-						
+
 						req_aux = req_aux->next;
 					}
 				}
@@ -264,7 +269,7 @@ static void *thread_func(void *arg)
 
 	starpu_variable_data_register(&thread_data->handle, 0, (uintptr_t)&thread_data->val, sizeof(unsigned));
 
-	for (iter = 0; iter < NITER; iter++)
+	for (iter = 0; iter < niter; iter++)
 	{
 		/* The first thread initiates the first transfer */
 		if (!((index == 0) && (iter == 0)))
@@ -274,10 +279,10 @@ static void *thread_func(void *arg)
 				recv_handle_async, thread_data
 			);
 		}
-		
+
 		increment_handle_async(thread_data);
 
-		if (!((index == (NTHREADS - 1)) && (iter == (NITER - 1))))
+		if (!((index == (nthreads - 1)) && (iter == (niter - 1))))
 		{
 			starpu_data_acquire_cb(
 				thread_data->handle, STARPU_R,
@@ -297,10 +302,14 @@ int main(int argc, char **argv)
 	int ret;
 	void *retval;
 
+#ifdef STARPU_SLOW_MACHINE
+	niter /= 16;
+	nthreads /= 4;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
-
 	/* Create a thread to perform blocking calls */
 	pthread_t progress_thread;
 	_STARPU_PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
@@ -309,13 +318,13 @@ int main(int argc, char **argv)
 	progress_thread_running = 0;
 
 	unsigned t;
-	for (t = 0; t < NTHREADS; t++)
+	for (t = 0; t < nthreads; t++)
 	{
 		problem_data[t].index = t;
 		problem_data[t].val = 0;
 		_STARPU_PTHREAD_MUTEX_INIT(&problem_data[t].recv_mutex, NULL);
 		problem_data[t].recv_flag = 0;
-		problem_data[t].neighbour = &problem_data[(t+1)%NTHREADS];
+		problem_data[t].neighbour = &problem_data[(t+1)%nthreads];
 	}
 
 	pthread_create(&progress_thread, NULL, progress_func, NULL);
@@ -325,13 +334,13 @@ int main(int argc, char **argv)
 		_STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
-	for (t = 0; t < NTHREADS; t++)
+	for (t = 0; t < nthreads; t++)
 	{
 		ret = pthread_create(&problem_data[t].thread, NULL, thread_func, &problem_data[t]);
 		STARPU_ASSERT(!ret);
 	}
 
-	for (t = 0; t < NTHREADS; t++)
+	for (t = 0; t < nthreads; t++)
 	{
 		ret = pthread_join(problem_data[t].thread, &retval);
 		STARPU_ASSERT(!ret);
@@ -348,16 +357,16 @@ int main(int argc, char **argv)
 	STARPU_ASSERT(retval == NULL);
 
 	/* We check that the value in the "last" thread is valid */
-	starpu_data_handle_t last_handle = problem_data[NTHREADS - 1].handle;
+	starpu_data_handle_t last_handle = problem_data[nthreads - 1].handle;
 	starpu_data_acquire(last_handle, STARPU_R);
-	if (problem_data[NTHREADS - 1].val != (NTHREADS * NITER))
+	if (problem_data[nthreads - 1].val != (nthreads * niter))
 	{
-		FPRINTF(stderr, "Final value : %u should be %d\n", problem_data[NTHREADS - 1].val, (NTHREADS * NITER));
+		FPRINTF(stderr, "Final value : %u should be %d\n", problem_data[nthreads - 1].val, (nthreads * niter));
 		STARPU_ABORT();
 	}
 	starpu_data_release(last_handle);
 
-	for (t = 0; t < NTHREADS; t++)
+	for (t = 0; t < nthreads; t++)
 	{
 		starpu_data_unregister(problem_data[t].handle);
 	}

tests/datawizard/reclaim.c

@@ -86,6 +86,11 @@ int main(int argc, char **argv)
 	if (2*mb > ntasks)
 		ntasks = 2*mb;
 
+#ifdef STARPU_SLOW_MACHINE
+	mb /= 100;
+	ntasks /= 100;
+#endif
+
 	FPRINTF(stderr, "Allocate %d buffers and create %u tasks\n", mb, ntasks);
 
         ret = starpu_init(NULL);

tests/datawizard/scratch.c

@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include "../helper.h"
 
+#warning memory leaks
+
 #define NLOOPS		128
 #define VECTORSIZE	1024
 

tests/datawizard/sync_and_notify_data.c

@@ -28,8 +28,11 @@
 
 #include "../helper.h"
 
-#define N	100
-#define K	256
+#define N_DEF	100
+#define K_DEF	256
+
+static int n=N_DEF;
+static int k=K_DEF;
 
 /*
  * In this test, we maintain a vector v = (a,b,c).
@@ -83,6 +86,11 @@ int main(int argc, char **argv)
 {
 	int ret;
 
+#ifdef STARPU_SLOW_MACHINE
+	n /= 10;
+	k /= 8;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -108,11 +116,11 @@ int main(int argc, char **argv)
         starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned iter;
-	for (iter = 0; iter < K; iter++)
+	for (iter = 0; iter < k; iter++)
 	{
 		int ret;
 		unsigned ind;
-		for (ind = 0; ind < N; ind++)
+		for (ind = 0; ind < n; ind++)
 		{
 			/* increment a = v[0] */
 			struct starpu_codelet cl_inc_a =
@@ -153,7 +161,7 @@ int main(int argc, char **argv)
 
 		starpu_data_release(v_handle);
 
-		for (ind = 0; ind < N; ind++)
+		for (ind = 0; ind < n; ind++)
 		{
 			/* increment c = v[2] */
 			struct starpu_codelet cl_inc_c =
@@ -199,7 +207,7 @@ int main(int argc, char **argv)
 
 	starpu_shutdown();
 
-	if ((v[0] != N*K) || (v[1] != K) || (v[2] != N*K))
+	if ((v[0] != n*k) || (v[1] != k) || (v[2] != n*k))
 	{
 		FPRINTF(stderr, "Incorrect result\n");
 		return EXIT_FAILURE;

tests/datawizard/sync_and_notify_data_implicit.c

@@ -27,10 +27,11 @@
 
 #include "../helper.h"
 
-#define N	100
-#define K	256
-//#define N	1
-//#define K	1
+#define N_DEF	100
+#define K_DEF	256
+
+static int n=N_DEF;
+static int k=K_DEF;
 
 /*
  * In this test, we maintain a vector v = (a,b,c).
@@ -120,6 +121,11 @@ int main(int argc, char **argv)
 {
 	int ret;
 
+#ifdef STARPU_SLOW_MACHINE
+	n /= 10;
+	k /= 8;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -145,11 +151,11 @@ int main(int argc, char **argv)
         starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned iter;
-	for (iter = 0; iter < K; iter++)
+	for (iter = 0; iter < k; iter++)
 	{
 		int ret;
 		unsigned ind;
-		for (ind = 0; ind < N; ind++)
+		for (ind = 0; ind < n; ind++)
 		{
 			struct starpu_task *task = starpu_task_create();
 			task->cl = &cl_inc_a;
@@ -169,7 +175,7 @@ int main(int argc, char **argv)
 
 		starpu_data_release(v_handle);
 
-		for (ind = 0; ind < N; ind++)
+		for (ind = 0; ind < n; ind++)
 		{
 			struct starpu_task *task = starpu_task_create();
 			task->cl = &cl_inc_c;
@@ -191,7 +197,7 @@ int main(int argc, char **argv)
 	starpu_data_unregister(v_handle);
 	starpu_shutdown();
 
-	if ((v[0] != N*K) || (v[1] != K) || (v[2] != N*K))
+	if ((v[0] != n*k) || (v[1] != k) || (v[2] != n*k))
 	{
 		FPRINTF(stderr, "Incorrect result\n");
 		return EXIT_FAILURE;

tests/datawizard/sync_with_data_with_mem.c

@@ -22,13 +22,19 @@
 #include <stdlib.h>
 #include "../helper.h"
 
-#define NBUFFERS	64
-#define NITER		128
-#define VECTORSIZE	1024
+#warning memory leak
 
-float *buffer[NBUFFERS];
+#define NBUFFERS_DEF	64
+#define NITER_DEF	128
+#define VECTORSIZE_DEF	1024
 
-starpu_data_handle_t v_handle[NBUFFERS];
+static int nbuffers = NBUFFERS_DEF;
+static int niter = NITER_DEF;
+static int vectorsize = VECTORSIZE_DEF;
+
+float *buffer[NBUFFERS_DEF];
+
+starpu_data_handle_t v_handle[NBUFFERS_DEF];
 
 static void dummy_codelet(void *descr[], __attribute__ ((unused)) void *_args)
 {
@@ -66,26 +72,32 @@ int main(int argc, char **argv)
 {
 	int ret;
 
+#ifdef STARPU_SLOW_MACHINE
+	nbuffers /= 4;
+	niter /= 4;
+	vectorsize /= 8;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	/* Allocate all buffers and register them to StarPU */
 	unsigned b;
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
-		ret = starpu_malloc((void **)&buffer[b], VECTORSIZE);
+		ret = starpu_malloc((void **)&buffer[b], vectorsize);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
 		starpu_vector_data_register(&v_handle[b], 0,
-				(uintptr_t)buffer[b], VECTORSIZE, sizeof(char));
+				(uintptr_t)buffer[b], vectorsize, sizeof(char));
 	}
 
 	unsigned iter;
-	for (iter = 0; iter < NITER; iter++)
+	for (iter = 0; iter < niter; iter++)
 	{
 		/* Use the buffers on the different workers so that it may not
 		 * be in main memory anymore */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = use_handle(v_handle[b]);
 			if (ret == -ENODEV) goto enodev;
@@ -96,19 +108,19 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 		/* Grab the different pieces of data into main memory */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = starpu_data_acquire(v_handle[b], STARPU_RW);
 			STARPU_CHECK_RETURN_VALUE(ret, "starpu_data_acquire");
 		}
 
 		/* Release them */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 			starpu_data_release(v_handle[b]);
 	}
 
 	/* do some cleanup */
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
 		starpu_free(buffer[b]);

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -23,13 +23,19 @@
 #include <pthread.h>
 #include "../helper.h"
 
-#define NBUFFERS	64
-#define NITER		128
-#define VECTORSIZE	1024
+#warning memory leak
 
-float *buffer[NBUFFERS];
+#define NBUFFERS_DEF	64
+#define NITER_DEF	128
+#define VECTORSIZE_DEF	1024
 
-starpu_data_handle_t v_handle[NBUFFERS];
+static int nbuffers = NBUFFERS_DEF;
+static int niter = NITER_DEF;
+static int vectorsize = VECTORSIZE_DEF;
+
+float *buffer[NBUFFERS_DEF];
+
+starpu_data_handle_t v_handle[NBUFFERS_DEF];
 
 static void dummy_codelet(void *descr[], __attribute__ ((unused)) void *_args)
 {
@@ -73,7 +79,7 @@ void callback_sync_data(void *arg __attribute__ ((unused)))
 
 	n_synced_buffers++;
 
-	if (n_synced_buffers == NBUFFERS)
+	if (n_synced_buffers == nbuffers)
 		_STARPU_PTHREAD_COND_SIGNAL(&cond);
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
@@ -83,27 +89,33 @@ int main(int argc, char **argv)
 {
 	int ret;
 
+#ifdef STARPU_SLOW_MACHINE
+	nbuffers /= 4;
+	niter /= 4;
+	vectorsize /= 8;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	/* Allocate all buffers and register them to StarPU */
 	unsigned b;
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
-		ret = starpu_malloc((void **)&buffer[b], VECTORSIZE);
+		ret = starpu_malloc((void **)&buffer[b], vectorsize);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
 		starpu_vector_data_register(&v_handle[b], 0,
-				(uintptr_t)buffer[b], VECTORSIZE, sizeof(char));
+				(uintptr_t)buffer[b], vectorsize, sizeof(char));
 		starpu_data_set_sequential_consistency_flag(v_handle[b], 0);
 	}
 
 	unsigned iter;
-	for (iter = 0; iter < NITER; iter++)
+	for (iter = 0; iter < niter; iter++)
 	{
 		/* Use the buffers on the different workers so that it may not
 		 * be in main memory anymore */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = use_handle(v_handle[b]);
 			if (ret == -ENODEV) goto enodev;
@@ -118,7 +130,7 @@ int main(int argc, char **argv)
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = starpu_data_acquire_cb(v_handle[b], STARPU_RW,
 						     callback_sync_data, NULL);
@@ -128,18 +140,18 @@ int main(int argc, char **argv)
 		/* Wait for all buffers to be available */
 		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
-		while (n_synced_buffers != NBUFFERS)
+		while (n_synced_buffers != nbuffers)
 			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 			starpu_data_release(v_handle[b]);
 	}
 
 	/* do some cleanup */
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
 		starpu_free(buffer[b]);

tests/datawizard/sync_with_data_with_mem_non_blocking_implicit.c

@@ -23,13 +23,19 @@
 #include <pthread.h>
 #include "../helper.h"
 
-#define NBUFFERS	64
-#define NITER		128
-#define VECTORSIZE	1024
+#warning memory leak
 
-float *buffer[NBUFFERS];
+#define NBUFFERS_DEF	64
+#define NITER_DEF	128
+#define VECTORSIZE_DEF	1024
 
-starpu_data_handle_t v_handle[NBUFFERS];
+static int nbuffers = NBUFFERS_DEF;
+static int niter = NITER_DEF;
+static int vectorsize = VECTORSIZE_DEF;
+
+float *buffer[NBUFFERS_DEF];
+
+starpu_data_handle_t v_handle[NBUFFERS_DEF];
 
 static void dummy_codelet(void *descr[], __attribute__ ((unused)) void *_args)
 {
@@ -73,7 +79,7 @@ void callback_sync_data(void *arg __attribute__ ((unused)))
 
 	n_synced_buffers++;
 
-	if (n_synced_buffers == NBUFFERS)
+	if (n_synced_buffers == nbuffers)
 		_STARPU_PTHREAD_COND_SIGNAL(&cond);
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
@@ -83,26 +89,32 @@ int main(int argc, char **argv)
 {
 	int ret;
 
+#ifdef STARPU_SLOW_MACHINE
+	nbuffers /= 4;
+	niter /= 4;
+	vectorsize /= 8;
+#endif
+
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	/* Allocate all buffers and register them to StarPU */
 	unsigned b;
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
-		ret = starpu_malloc((void **)&buffer[b], VECTORSIZE);
+		ret = starpu_malloc((void **)&buffer[b], vectorsize);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
 		starpu_vector_data_register(&v_handle[b], 0,
-				(uintptr_t)buffer[b], VECTORSIZE, sizeof(char));
+				(uintptr_t)buffer[b], vectorsize, sizeof(char));
 	}
 
 	unsigned iter;
-	for (iter = 0; iter < NITER; iter++)
+	for (iter = 0; iter < niter; iter++)
 	{
 		/* Use the buffers on the different workers so that it may not
 		 * be in main memory anymore */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = use_handle(v_handle[b]);
 			if (ret == -ENODEV) goto enodev;
@@ -114,7 +126,7 @@ int main(int argc, char **argv)
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 		{
 			ret = starpu_data_acquire_cb(v_handle[b], STARPU_RW,
 						     callback_sync_data, NULL);
@@ -124,13 +136,13 @@ int main(int argc, char **argv)
 		/* Wait for all buffers to be available */
 		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
-		while (n_synced_buffers != NBUFFERS)
+		while (n_synced_buffers != nbuffers)
 			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
-		for (b = 0; b < NBUFFERS; b++)
+		for (b = 0; b < nbuffers; b++)
 			starpu_data_release(v_handle[b]);
 	}
 
@@ -138,7 +150,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	/* do some cleanup */
-	for (b = 0; b < NBUFFERS; b++)
+	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
 		starpu_free(buffer[b]);