replace 0 with macro part 4

tests/errorcheck/invalid_blocking_calls.c

@@ -77,7 +77,7 @@ int main(int argc, char **argv)
 	*data = 42;
 
 	/* register a piece of data */
-	starpu_vector_data_register(&handle, 0, (uintptr_t)data,
+	starpu_vector_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)data,
 						1, sizeof(unsigned));
 
 	struct starpu_task *task = starpu_task_create();

tests/helper/starpu_data_cpy.c

@@ -30,8 +30,8 @@ int main(int argc, char **argv)
 	var1 = 42;
 	var2 = 12;
 
-	starpu_variable_data_register(&var1_handle, 0, (uintptr_t)&var1, sizeof(var1));
-	starpu_variable_data_register(&var2_handle, 0, (uintptr_t)&var2, sizeof(var2));
+	starpu_variable_data_register(&var1_handle, STARPU_MAIN_RAM, (uintptr_t)&var1, sizeof(var1));
+	starpu_variable_data_register(&var2_handle, STARPU_MAIN_RAM, (uintptr_t)&var2, sizeof(var2));
 
 	ret = starpu_data_cpy(var2_handle, var1_handle, 0, NULL, NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_data_cpy");

tests/main/deprecated_buffer.c

@@ -114,8 +114,8 @@ int submit_codelet(struct starpu_codelet cl, struct submit_task_func func)
 	starpu_data_handle_t handles[2];
 	int ret;
 
-	starpu_variable_data_register(&handles[0], 0, (uintptr_t)x, sizeof(*x));
-	starpu_variable_data_register(&handles[1], 0, (uintptr_t)y, sizeof(*y));
+	starpu_variable_data_register(&handles[0], STARPU_MAIN_RAM, (uintptr_t)x, sizeof(*x));
+	starpu_variable_data_register(&handles[1], STARPU_MAIN_RAM, (uintptr_t)y, sizeof(*y));
 
 	ret = func.func(cl, handles[0], handles[1]);
 	starpu_data_unregister(handles[0]);

tests/main/deprecated_func.c

@@ -78,8 +78,8 @@ int submit_codelet(struct starpu_codelet cl, int where)
 	starpu_data_handle_t handles[2];
 	int ret;
 
-	starpu_variable_data_register(&handles[0], 0, (uintptr_t)&x, sizeof(x));
-	starpu_variable_data_register(&handles[1], 0, (uintptr_t)&y, sizeof(y));
+	starpu_variable_data_register(&handles[0], STARPU_MAIN_RAM, (uintptr_t)&x, sizeof(x));
+	starpu_variable_data_register(&handles[1], STARPU_MAIN_RAM, (uintptr_t)&y, sizeof(y));
 
 	cl.where = where;
 	ret = starpu_insert_task(&cl,

tests/main/execute_on_a_specific_worker.c

@@ -119,7 +119,7 @@ int main(int argc, char **argv)
 	ret = starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
 
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned nworker = starpu_worker_get_count();
 

tests/main/insert_task.c

@@ -61,9 +61,9 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	x = 1;
-	starpu_variable_data_register(&data_handles[0], 0, (uintptr_t)&x, sizeof(x));
+	starpu_variable_data_register(&data_handles[0], STARPU_MAIN_RAM, (uintptr_t)&x, sizeof(x));
 	f = 2.0;
-	starpu_variable_data_register(&data_handles[1], 0, (uintptr_t)&f, sizeof(f));
+	starpu_variable_data_register(&data_handles[1], STARPU_MAIN_RAM, (uintptr_t)&f, sizeof(f));
 
         FPRINTF(stderr, "VALUES: %d (%d) %f (%f)\n", x, ifactor, f, ffactor);
 

tests/main/insert_task_array.c

@@ -50,9 +50,9 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	x = 1;
-	starpu_variable_data_register(&data_handles[0], 0, (uintptr_t)&x, sizeof(x));
+	starpu_variable_data_register(&data_handles[0], STARPU_MAIN_RAM, (uintptr_t)&x, sizeof(x));
 	f = 2.0;
-	starpu_variable_data_register(&data_handles[1], 0, (uintptr_t)&f, sizeof(f));
+	starpu_variable_data_register(&data_handles[1], STARPU_MAIN_RAM, (uintptr_t)&f, sizeof(f));
 
         ret = starpu_insert_task(&mycodelet,
 				 STARPU_DATA_ARRAY, data_handles, 2,

tests/main/starpu_task_bundle.c

@@ -64,7 +64,7 @@ int main(int argc, char **argv)
 	}
 
 	for (i = 0; i < NB_BUNDLE; i++)
-		starpu_variable_data_register(&handles[i], 0, (uintptr_t)&data[i], sizeof(float));
+		starpu_variable_data_register(&handles[i], STARPU_MAIN_RAM, (uintptr_t)&data[i], sizeof(float));
 
         FPRINTF(stderr, "VALUES:");
 	for (i = 0; i < NB_BUNDLE; i++)

tests/main/subgraph_repeat.c

@@ -112,7 +112,7 @@ int main(int argc, char **argv)
 	*check_cnt = 0;
 
 	starpu_data_handle_t check_data;
-	starpu_variable_data_register(&check_data, 0, (uintptr_t)check_cnt, sizeof(*check_cnt));
+	starpu_variable_data_register(&check_data, STARPU_MAIN_RAM, (uintptr_t)check_cnt, sizeof(*check_cnt));
 
 	starpu_task_init(&taskA);
 	taskA.cl = &dummy_codelet;

tests/main/subgraph_repeat_regenerate.c

@@ -112,7 +112,7 @@ int main(int argc, char **argv)
 	*check_cnt = 0;
 
 	starpu_data_handle_t check_data;
-	starpu_variable_data_register(&check_data, 0, (uintptr_t)check_cnt, sizeof(*check_cnt));
+	starpu_variable_data_register(&check_data, STARPU_MAIN_RAM, (uintptr_t)check_cnt, sizeof(*check_cnt));
 
 	starpu_task_init(&taskA);
 	taskA.cl = &dummy_codelet;

tests/main/subgraph_repeat_regenerate_tag.c

@@ -117,7 +117,7 @@ int main(int argc, char **argv)
 	*check_cnt = 0;
 
 	starpu_data_handle_t check_data;
-	starpu_variable_data_register(&check_data, 0, (uintptr_t)check_cnt, sizeof(*check_cnt));
+	starpu_variable_data_register(&check_data, STARPU_MAIN_RAM, (uintptr_t)check_cnt, sizeof(*check_cnt));
 
 	starpu_task_init(&taskA);
 	taskA.cl = &dummy_codelet;

tests/main/subgraph_repeat_tag.c

@@ -111,7 +111,7 @@ int main(int argc, char **argv)
 	*check_cnt = 0;
 
 	starpu_data_handle_t check_data;
-	starpu_variable_data_register(&check_data, 0, (uintptr_t)check_cnt, sizeof(*check_cnt));
+	starpu_variable_data_register(&check_data, STARPU_MAIN_RAM, (uintptr_t)check_cnt, sizeof(*check_cnt));
 
 	starpu_task_init(&taskA);
 	taskA.cl = &dummy_codelet;

tests/microbenchs/local_pingpong.c

@@ -53,7 +53,7 @@ int main(int argc, char **argv)
 	/* Create a piece of data */
 	ret = starpu_malloc((void **)&v, vector_size);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, vector_size, 1);
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, vector_size, 1);
 
 	/* Find a pair of memory nodes */
 	if (starpu_cuda_worker_get_count() > 1)

tests/microbenchs/matrix_as_vector.c

@@ -105,7 +105,7 @@ int check_size(int nx, struct starpu_codelet *vector_codelet, struct starpu_code
 	for(loop=1 ; loop<=maxloops ; loop++)
 	{
 		for(i=0 ; i<nx ; i++) matrix[i] = i;
-		starpu_vector_data_register(&vector_handle, 0, (uintptr_t)matrix, nx, sizeof(matrix[0]));
+		starpu_vector_data_register(&vector_handle, STARPU_MAIN_RAM, (uintptr_t)matrix, nx, sizeof(matrix[0]));
 		ret = starpu_insert_task(vector_codelet, STARPU_RW, vector_handle, 0);
 		starpu_data_unregister(vector_handle);
 		if (ret == -ENODEV) goto end;
@@ -120,7 +120,7 @@ int check_size(int nx, struct starpu_codelet *vector_codelet, struct starpu_code
 	for(loop=1 ; loop<=maxloops ; loop++)
 	{
 		for(i=0 ; i<nx ; i++) matrix[i] = i;
-		starpu_matrix_data_register(&matrix_handle, 0, (uintptr_t)matrix, nx/2, nx/2, 2, sizeof(matrix[0]));
+		starpu_matrix_data_register(&matrix_handle, STARPU_MAIN_RAM, (uintptr_t)matrix, nx/2, nx/2, 2, sizeof(matrix[0]));
 		ret = starpu_insert_task(matrix_codelet, STARPU_RW, matrix_handle, 0);
 		starpu_data_unregister(matrix_handle);
 		if (ret == -ENODEV) goto end;

tests/microbenchs/prefetch_data_on_node.c

@@ -101,7 +101,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned nworker = starpu_worker_get_count();
 
@@ -112,7 +112,7 @@ int main(int argc, char **argv)
 		{
 			/* synchronous prefetch */
 			unsigned node = starpu_worker_get_memory_node(worker);
-			ret = starpu_data_prefetch_on_node(v_handle, node, 0);
+			ret = starpu_data_prefetch_on_node(v_handle, node, STARPU_MAIN_RAM);
 			STARPU_CHECK_RETURN_VALUE(ret, "starpu_data_prefetch_on_node");
 
 			/* execute a task */

tests/microbenchs/redundant_buffer.c

@@ -62,7 +62,7 @@ int main(int argc, char **argv)
 
 	starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
 
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned iter;
 	for (iter = 0; iter < N; iter++)

tests/microbenchs/tasks_overhead.c

@@ -105,7 +105,7 @@ int main(int argc, char **argv)
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
 		starpu_malloc((void**)&buffers[buffer], 16*sizeof(float));
-		starpu_vector_data_register(&data_handles[buffer], 0, (uintptr_t)buffers[buffer], 16, sizeof(float));
+		starpu_vector_data_register(&data_handles[buffer], STARPU_MAIN_RAM, (uintptr_t)buffers[buffer], 16, sizeof(float));
 	}
 
 	fprintf(stderr, "#tasks : %u\n#buffers : %u\n", ntasks, nbuffers);

tests/microbenchs/tasks_size_overhead.c

@@ -162,7 +162,7 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 		for (buffer = 0; buffer < nbuffers; buffer++)
-			starpu_vector_data_register(&data_handles[buffer], 0, (uintptr_t)buffers[buffer], 16, sizeof(float));
+			starpu_vector_data_register(&data_handles[buffer], STARPU_MAIN_RAM, (uintptr_t)buffers[buffer], 16, sizeof(float));
 
 		for (size = START; size <= STOP; size *= FACTOR)
 		{

tests/overlap/overlap.c

@@ -94,7 +94,7 @@ int main(int argc, char **argv)
 	starpu_malloc((void **)&buffer, NTASKS*VECTORSIZE*sizeof(char));
 
 	/* declare data to StarPU */
-	starpu_vector_data_register(&handle, 0, (uintptr_t)buffer,
+	starpu_vector_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)buffer,
 					NTASKS*VECTORSIZE, sizeof(char));
 
 	struct starpu_data_filter f =
@@ -130,7 +130,7 @@ int main(int argc, char **argv)
 		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
-	starpu_data_unpartition(handle, 0);
+	starpu_data_unpartition(handle, STARPU_MAIN_RAM);
 	starpu_data_unregister(handle);
 	starpu_free(buffer);
 	starpu_shutdown();

tests/parallel_tasks/explicit_combined_worker.c

@@ -66,7 +66,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned nworker = starpu_worker_get_count() + starpu_combined_worker_get_count();
 

tests/parallel_tasks/parallel_kernels.c

@@ -73,7 +73,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned nworker = starpu_worker_get_count() + starpu_combined_worker_get_count();
 

tests/parallel_tasks/parallel_kernels_spmd.c

@@ -75,7 +75,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned nworker = starpu_worker_get_count() + starpu_combined_worker_get_count();
 

tests/parallel_tasks/spmd_peager.c

@@ -70,7 +70,7 @@ int main(int argc, char **argv)
 
 	ret = starpu_malloc((void **)&v, VECTORSIZE*sizeof(unsigned));
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
-	starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned iter;//, worker;
 	for (iter = 0; iter < N; iter++)

tests/sched_policies/data_locality.c

@@ -71,7 +71,7 @@ static starpu_data_handle_t rw_handle;
 static void
 init_data(void)
 {
-	starpu_variable_data_register(&rw_handle, 0, (uintptr_t) &var,
+	starpu_variable_data_register(&rw_handle, STARPU_MAIN_RAM, (uintptr_t) &var,
 					sizeof(var));
 }