Rename the functions that permit to access the memory managed by StarPU from

the application with an acquire/release semantic, and adapt the renaming script
accordingly.

starpu_data_sync_with_mem -> starpu_data_acquire
starpu_data_sync_with_mem_non_blocking -> starpu_data_acquire_cb
starpu_data_release_from_mem -> starpu_data_release

doc/starpu.texi

@@ -1162,7 +1162,7 @@ undefined behaviour.
 @code{void starpu_data_unregister(starpu_data_handle handle);}
 @end table
 @c user interaction with the DSM
-@c   void starpu_data_sync_with_mem(struct starpu_data_state_t *state);
+@c   void starpu_data_acquire(struct starpu_data_state_t *state);
 @c   void starpu_notify_data_modification(struct starpu_data_state_t *state, uint32_t modifying_node);
 @c   struct starpu_data_interface_ops_t *ops
 
@@ -2684,7 +2684,7 @@ int main(int argc, char **argv)
     starpu_task_wait_for_all();
 
     /* @b{Update the vector in RAM} */
-    starpu_data_sync_with_mem(vector_handle, STARPU_R);
+    starpu_data_acquire(vector_handle, STARPU_R);
 @end smallexample
 @end cartouche
 
@@ -2697,7 +2697,7 @@ int main(int argc, char **argv)
     fprintf(stderr, "\n");
 
     /* @b{Release the data and shutdown StarPU} */
-    starpu_data_release_from_mem(vector_handle);
+    starpu_data_release(vector_handle);
     starpu_shutdown();
 
     return 0;

examples/block/block.c

@@ -108,14 +108,14 @@ int execute_on(uint32_t where, device_func func, float *block, int pnx, int pny,
 	starpu_task_wait_for_all();
 
 	/* update the array in RAM */
-        starpu_data_sync_with_mem(block_handle, STARPU_R);
+        starpu_data_acquire(block_handle, STARPU_R);
 
         for(i=0 ; i<pnx*pny*pnz; i++) {
           fprintf(stderr, "%f ", block[i]);
         }
         fprintf(stderr, "\n");
 
-        starpu_data_release_from_mem(block_handle);
+        starpu_data_release(block_handle);
 
         return 0;
 }

examples/incrementer/incrementer.c

@@ -97,7 +97,7 @@ int main(int argc, char **argv)
 	starpu_task_wait_for_all();
 
 	/* update the array in RAM */
-	starpu_data_sync_with_mem(float_array_handle, STARPU_R);
+	starpu_data_acquire(float_array_handle, STARPU_R);
 
 	gettimeofday(&end, NULL);
 
@@ -109,7 +109,7 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	starpu_data_release_from_mem(float_array_handle);
+	starpu_data_release(float_array_handle);
 
 	double timing = (double)((end.tv_sec - start.tv_sec)*1000000 +
 					(end.tv_usec - start.tv_usec));

examples/matvecmult/matvecmult.c

@@ -181,9 +181,9 @@ int main(int argc, char **argv)
 	starpu_task_wait_for_all();
 
 	/* update the array in RAM */
-        starpu_data_sync_with_mem(matrix_handle, STARPU_R);
-        starpu_data_sync_with_mem(vector_handle, STARPU_R);
-        starpu_data_sync_with_mem(mult_handle, STARPU_R);
+        starpu_data_acquire(matrix_handle, STARPU_R);
+        starpu_data_acquire(vector_handle, STARPU_R);
+        starpu_data_acquire(mult_handle, STARPU_R);
 
         int res = compareL2fe(correctResult, mult, height, 1e-6f);
         printf("TEST %s\n\n", (res == 0) ? "PASSED" : "FAILED !!!");
@@ -192,9 +192,9 @@ int main(int argc, char **argv)
         printArray(vector, width);
         printArray(mult, height);
 #endif
-        starpu_data_release_from_mem(matrix_handle);
-        starpu_data_release_from_mem(vector_handle);
-        starpu_data_release_from_mem(mult_handle);
+        starpu_data_release(matrix_handle);
+        starpu_data_release(vector_handle);
+        starpu_data_release(mult_handle);
 
         starpu_shutdown();
 

examples/pi/pi.c

@@ -146,7 +146,7 @@ int main(int argc, char **argv)
 
 	/* Get the cnt_array back in main memory */
 	starpu_data_unpartition(cnt_array_handle, 0);
-	starpu_data_sync_with_mem(cnt_array_handle, STARPU_RW);
+	starpu_data_acquire(cnt_array_handle, STARPU_RW);
 
 	/* Count the total number of entries */
 	unsigned long total_cnt = 0;
@@ -164,7 +164,7 @@ int main(int argc, char **argv)
 	fprintf(stderr, "Total time : %f ms\n", timing/1000.0);
 	fprintf(stderr, "Speed : %f GShot/s\n", total_shot_cnt/(1e3*timing));
 
-	starpu_data_release_from_mem(cnt_array_handle);
+	starpu_data_release(cnt_array_handle);
 
 	starpu_display_codelet_stats(&cl);
 

examples/ppm_downscaler/yuv_downscaler.c

@@ -297,9 +297,9 @@ int main(int argc, char **argv)
 	/* make sure all output buffers are sync'ed */
 	for (frame = 0; frame < nframes; frame++)
 	{
-		starpu_data_sync_with_mem(new_frame_y_handle[frame], STARPU_R);
-		starpu_data_sync_with_mem(new_frame_u_handle[frame], STARPU_R);
-		starpu_data_sync_with_mem(new_frame_v_handle[frame], STARPU_R);
+		starpu_data_acquire(new_frame_y_handle[frame], STARPU_R);
+		starpu_data_acquire(new_frame_u_handle[frame], STARPU_R);
+		starpu_data_acquire(new_frame_v_handle[frame], STARPU_R);
 	}
 
 	/* partition the layers into smaller parts */

examples/variable/variable.c

@@ -90,11 +90,11 @@ int main(int argc, char **argv)
 	starpu_task_wait_for_all();
 
 	/* update the array in RAM */
-	starpu_data_sync_with_mem(float_array_handle, STARPU_R);
+	starpu_data_acquire(float_array_handle, STARPU_R);
 
 	fprintf(stderr, "variable -> %f\n", foo);
 
-	starpu_data_release_from_mem(float_array_handle);
+	starpu_data_release(float_array_handle);
 
 	starpu_shutdown();
 

include/starpu_data.h

@@ -48,10 +48,10 @@ void starpu_data_unregister(starpu_data_handle handle);
 
 void starpu_data_advise_as_important(starpu_data_handle handle, unsigned is_important);
 
-int starpu_data_sync_with_mem(starpu_data_handle handle, starpu_access_mode mode);
-int starpu_data_sync_with_mem_non_blocking(starpu_data_handle handle,
+int starpu_data_acquire(starpu_data_handle handle, starpu_access_mode mode);
+int starpu_data_acquire_cb(starpu_data_handle handle,
 			starpu_access_mode mode, void (*callback)(void *), void *arg);
-void starpu_data_release_from_mem(starpu_data_handle handle);
+void starpu_data_release(starpu_data_handle handle);
 
 int starpu_data_malloc_pinned_if_possible(void **A, size_t dim);
 int starpu_data_free_pinned_if_possible(void *A);

mpi/examples/mpi_lu/pxlu.c

@@ -774,7 +774,7 @@ static void wait_tag_and_fetch_handle(starpu_tag_t tag, starpu_data_handle handl
 	starpu_tag_wait(tag);
 //	fprintf(stderr, "Rank %d : tag %lx is done\n", rank, tag);
 
-	starpu_data_sync_with_mem(handle, STARPU_R);
+	starpu_data_acquire(handle, STARPU_R);
 
 //	starpu_data_unregister(handle);
 }

mpi/starpu_mpi.c

@@ -97,7 +97,7 @@ static struct starpu_mpi_req_s *_starpu_mpi_isend_common(starpu_data_handle data
 	/* Asynchronously request StarPU to fetch the data in main memory: when
 	 * it is available in main memory, submit_mpi_req(req) is called and
 	 * the request is actually submitted  */
-	starpu_data_sync_with_mem_non_blocking(data_handle, STARPU_R,
+	starpu_data_acquire_cb(data_handle, STARPU_R,
 			submit_mpi_req, (void *)req);
 
 	return req;
@@ -181,7 +181,7 @@ static struct starpu_mpi_req_s *_starpu_mpi_irecv_common(starpu_data_handle data
 	/* Asynchronously request StarPU to fetch the data in main memory: when
 	 * it is available in main memory, submit_mpi_req(req) is called and
 	 * the request is actually submitted  */
-	starpu_data_sync_with_mem_non_blocking(data_handle, STARPU_W,
+	starpu_data_acquire_cb(data_handle, STARPU_W,
 			submit_mpi_req, (void *)req);
 
 	return req;
@@ -382,7 +382,7 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
 static void handle_request_termination(struct starpu_mpi_req_s *req)
 {
 	MPI_Type_free(&req->datatype);
-	starpu_data_release_from_mem(req->data_handle);
+	starpu_data_release(req->data_handle);
 
 #ifdef VERBOSE_STARPU_MPI
 	int rank;

mpi/tests/block_interface.c

@@ -94,7 +94,7 @@ int main(int argc, char **argv)
 		starpu_mpi_recv(block_handle, 1, 0x1337, MPI_COMM_WORLD, &status);
 
 		/* check the content of the block */
-		starpu_data_sync_with_mem(block_handle, STARPU_R);
+		starpu_data_acquire(block_handle, STARPU_R);
 		unsigned i, j, k;
 		for (k = 0; k < SIZE; k++)
 		for (j = 0; j < SIZE; j++)
@@ -102,7 +102,7 @@ int main(int argc, char **argv)
 		{
 			assert(block[i + j*BIGSIZE + k*BIGSIZE*BIGSIZE] == 33.0f);
 		}
-		starpu_data_release_from_mem(block_handle);
+		starpu_data_release(block_handle);
 		
 	}
 	else /* rank == 1 */
@@ -111,7 +111,7 @@ int main(int argc, char **argv)
 		starpu_mpi_recv(block_handle, 0, 0x42, MPI_COMM_WORLD, &status);
 
 		/* check the content of the block and modify it */
-		starpu_data_sync_with_mem(block_handle, STARPU_RW);
+		starpu_data_acquire(block_handle, STARPU_RW);
 		unsigned i, j, k;
 		for (k = 0; k < SIZE; k++)
 		for (j = 0; j < SIZE; j++)
@@ -120,7 +120,7 @@ int main(int argc, char **argv)
 			assert(block[i + j*SIZE + k*SIZE*SIZE] == 1.0f);
 			block[i + j*SIZE + k*SIZE*SIZE] = 33.0f;
 		}
-		starpu_data_release_from_mem(block_handle);
+		starpu_data_release(block_handle);
 
 		starpu_mpi_send(block_handle, 0, 0x1337, MPI_COMM_WORLD);
 	}

mpi/tests/block_interface_pinned.c

@@ -96,7 +96,7 @@ int main(int argc, char **argv)
 		starpu_mpi_recv(block_handle, 1, 0x1337, MPI_COMM_WORLD, &status);
 
 		/* check the content of the block */
-		starpu_data_sync_with_mem(block_handle, STARPU_R);
+		starpu_data_acquire(block_handle, STARPU_R);
 		unsigned i, j, k;
 		for (k = 0; k < SIZE; k++)
 		for (j = 0; j < SIZE; j++)
@@ -104,7 +104,7 @@ int main(int argc, char **argv)
 		{
 			assert(block[i + j*BIGSIZE + k*BIGSIZE*BIGSIZE] == 33.0f);
 		}
-		starpu_data_release_from_mem(block_handle);
+		starpu_data_release(block_handle);
 		
 	}
 	else /* rank == 1 */
@@ -113,7 +113,7 @@ int main(int argc, char **argv)
 		starpu_mpi_recv(block_handle, 0, 0x42, MPI_COMM_WORLD, &status);
 
 		/* check the content of the block and modify it */
-		starpu_data_sync_with_mem(block_handle, STARPU_RW);
+		starpu_data_acquire(block_handle, STARPU_RW);
 		unsigned i, j, k;
 		for (k = 0; k < SIZE; k++)
 		for (j = 0; j < SIZE; j++)
@@ -122,7 +122,7 @@ int main(int argc, char **argv)
 			assert(block[i + j*SIZE + k*SIZE*SIZE] == 1.0f);
 			block[i + j*SIZE + k*SIZE*SIZE] = 33.0f;
 		}
-		starpu_data_release_from_mem(block_handle);
+		starpu_data_release(block_handle);
 
 		starpu_mpi_send(block_handle, 0, 0x1337, MPI_COMM_WORLD);
 	}

mpi/tests/ring.c

@@ -106,9 +106,9 @@ int main(int argc, char **argv)
 		}
 		else {
 
-			starpu_data_sync_with_mem(token_handle, STARPU_R);
+			starpu_data_acquire(token_handle, STARPU_R);
 			fprintf(stdout, "Finished : token value %d\n", token);
-			starpu_data_release_from_mem(token_handle);
+			starpu_data_release(token_handle);
 		}
 	}
 

mpi/tests/ring_async.c

@@ -111,9 +111,9 @@ int main(int argc, char **argv)
 		}
 		else {
 
-			starpu_data_sync_with_mem(token_handle, STARPU_R);
+			starpu_data_acquire(token_handle, STARPU_R);
 			fprintf(stdout, "Finished : token value %d\n", token);
-			starpu_data_release_from_mem(token_handle);
+			starpu_data_release(token_handle);
 		}
 	}
 

mpi/tests/ring_async_implicit.c

@@ -103,9 +103,9 @@ int main(int argc, char **argv)
 		}
 		else {
 
-			starpu_data_sync_with_mem(token_handle, STARPU_R);
+			starpu_data_acquire(token_handle, STARPU_R);
 			fprintf(stdout, "Finished : token value %d\n", token);
-			starpu_data_release_from_mem(token_handle);
+			starpu_data_release(token_handle);
 		}
 	}
 

src/datawizard/user_interactions.c

@@ -65,7 +65,7 @@ static void _starpu_sync_data_with_mem_fetch_data_callback(void *arg)
 
 	/* At that moment, the caller holds a reference to the piece of data.
 	 * We enqueue the "post" sync task in the list associated to the handle
-	 * so that it is submitted by the starpu_data_release_from_mem
+	 * so that it is submitted by the starpu_data_release
 	 * function. */
 	_starpu_add_post_sync_tasks(wrapper->post_sync_task, handle);
 
@@ -101,8 +101,8 @@ static void starpu_data_sync_with_mem_non_blocking_pre_sync_callback(void *arg)
 	}
 }
 
-/* The data must be released by calling starpu_data_release_from_mem later on */
-int starpu_data_sync_with_mem_non_blocking(starpu_data_handle handle,
+/* The data must be released by calling starpu_data_release later on */
+int starpu_data_acquire_cb(starpu_data_handle handle,
 		starpu_access_mode mode, void (*callback)(void *), void *arg)
 {
 	STARPU_ASSERT(handle);
@@ -164,15 +164,15 @@ static inline void _starpu_sync_data_with_mem_continuation(void *arg)
 
 	_starpu_fetch_data_on_node(handle, 0, wrapper->mode, 0, NULL, NULL);
 	
-	/* continuation of starpu_data_sync_with_mem */
+	/* continuation of starpu_data_acquire */
 	PTHREAD_MUTEX_LOCK(&wrapper->lock);
 	wrapper->finished = 1;
 	PTHREAD_COND_SIGNAL(&wrapper->cond);
 	PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
 }
 
-/* The data must be released by calling starpu_data_release_from_mem later on */
-int starpu_data_sync_with_mem(starpu_data_handle handle, starpu_access_mode mode)
+/* The data must be released by calling starpu_data_release later on */
+int starpu_data_acquire(starpu_data_handle handle, starpu_access_mode mode)
 {
 	STARPU_ASSERT(handle);
 
@@ -190,7 +190,7 @@ int starpu_data_sync_with_mem(starpu_data_handle handle, starpu_access_mode mode
 		.finished = 0
 	};
 
-//	fprintf(stderr, "TAKE sequential_consistency_mutex starpu_data_sync_with_mem\n");
+//	fprintf(stderr, "TAKE sequential_consistency_mutex starpu_data_acquire\n");
 	PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 	int sequential_consistency = handle->sequential_consistency;
 	if (sequential_consistency)
@@ -233,16 +233,16 @@ int starpu_data_sync_with_mem(starpu_data_handle handle, starpu_access_mode mode
 
 	/* At that moment, the caller holds a reference to the piece of data.
 	 * We enqueue the "post" sync task in the list associated to the handle
-	 * so that it is submitted by the starpu_data_release_from_mem
+	 * so that it is submitted by the starpu_data_release
 	 * function. */
 	_starpu_add_post_sync_tasks(wrapper.post_sync_task, handle);
 
 	return 0;
 }
 
-/* This function must be called after starpu_data_sync_with_mem so that the
+/* This function must be called after starpu_data_acquire so that the
  * application release the data */
-void starpu_data_release_from_mem(starpu_data_handle handle)
+void starpu_data_release(starpu_data_handle handle)
 {
 	STARPU_ASSERT(handle);
 

tests/datawizard/mpi_like.c

@@ -85,7 +85,7 @@ static void increment_handle(struct thread_data *thread_data)
 
 static void recv_handle(struct thread_data *thread_data)
 {
-	starpu_data_sync_with_mem(thread_data->handle, STARPU_W);
+	starpu_data_acquire(thread_data->handle, STARPU_W);
 	pthread_mutex_lock(&thread_data->recv_mutex);
 
 	/* We wait for the previous thread to notify that the data is available */
@@ -102,14 +102,14 @@ static void recv_handle(struct thread_data *thread_data)
 //	fprintf(stderr, "Thread %d received value %d from thread %d\n", thread_data->index, thread_data->val, (thread_data->index - 1)%NTHREADS);
 
 	pthread_mutex_unlock(&thread_data->recv_mutex);
-	starpu_data_release_from_mem(thread_data->handle);
+	starpu_data_release(thread_data->handle);
 }
 
 static void send_handle(struct thread_data *thread_data)
 {
 	struct thread_data *neighbour_data = thread_data->neighbour;
 
-	starpu_data_sync_with_mem(thread_data->handle, STARPU_R);
+	starpu_data_acquire(thread_data->handle, STARPU_R);
 
 //	fprintf(stderr, "Thread %d sends value %d to thread %d\n", thread_data->index, thread_data->val, neighbour_data->index);
 	/* send the message */
@@ -124,7 +124,7 @@ static void send_handle(struct thread_data *thread_data)
 	
 	pthread_mutex_unlock(&neighbour_data->recv_mutex);
 
-	starpu_data_release_from_mem(thread_data->handle);
+	starpu_data_release(thread_data->handle);
 }
 
 static void *thread_func(void *arg)
@@ -186,13 +186,13 @@ int main(int argc, char **argv)
 
 	/* We check that the value in the "last" thread is valid */
 	starpu_data_handle last_handle = problem_data[NTHREADS - 1].handle;
-	starpu_data_sync_with_mem(last_handle, STARPU_R);
+	starpu_data_acquire(last_handle, STARPU_R);
 	if (problem_data[NTHREADS - 1].val != (NTHREADS * NITER))
 	{
 		fprintf(stderr, "Final value : %d should be %d\n", problem_data[NTHREADS - 1].val, (NTHREADS * NITER));
 		STARPU_ABORT();
 	}
-	starpu_data_release_from_mem(last_handle);
+	starpu_data_release(last_handle);
 
 	starpu_shutdown();
 

tests/datawizard/mpi_like_async.c

@@ -115,7 +115,7 @@ static int test_recv_handle_async(void *arg)
 		fprintf(stderr, "Thread %d received value %d from thread %d\n",
 			thread_data->index, thread_data->val, (thread_data->index - 1)%NTHREADS);
 #endif
-		starpu_data_release_from_mem(thread_data->handle);
+		starpu_data_release(thread_data->handle);
 	}
 	
 	return ret;
@@ -152,7 +152,7 @@ static int test_send_handle_async(void *arg)
 #ifdef DEBUG_MESSAGES
 		fprintf(stderr, "Thread %d sends value %d to thread %d\n", thread_data->index, thread_data->val, neighbour_data->index);
 #endif
-		starpu_data_release_from_mem(thread_data->handle);
+		starpu_data_release(thread_data->handle);
 	}
 
 	return ret;
@@ -255,7 +255,7 @@ static void *thread_func(void *arg)
 		/* The first thread initiates the first transfer */
 		if (!((index == 0) && (iter == 0)))
 		{
-			starpu_data_sync_with_mem_non_blocking(
+			starpu_data_acquire_cb(
 				thread_data->handle, STARPU_W,
 				recv_handle_async, thread_data
 			);
@@ -265,7 +265,7 @@ static void *thread_func(void *arg)
 
 		if (!((index == (NTHREADS - 1)) && (iter == (NITER - 1))))
 		{
-			starpu_data_sync_with_mem_non_blocking(
+			starpu_data_acquire_cb(
 				thread_data->handle, STARPU_R,
 				send_handle_async, thread_data
 			);
@@ -330,13 +330,13 @@ int main(int argc, char **argv)
 
 	/* We check that the value in the "last" thread is valid */
 	starpu_data_handle last_handle = problem_data[NTHREADS - 1].handle;
-	starpu_data_sync_with_mem(last_handle, STARPU_R);
+	starpu_data_acquire(last_handle, STARPU_R);
 	if (problem_data[NTHREADS - 1].val != (NTHREADS * NITER))
 	{
 		fprintf(stderr, "Final value : %d should be %d\n", problem_data[NTHREADS - 1].val, (NTHREADS * NITER));
 		STARPU_ABORT();
 	}
-	starpu_data_release_from_mem(last_handle);
+	starpu_data_release(last_handle);
 
 	starpu_shutdown();
 

tests/datawizard/scratch.c

@@ -85,7 +85,7 @@ int main(int argc, char **argv)
 	starpu_task_wait_for_all();
 
 	/* Make sure that data A is in main memory */
-	starpu_data_sync_with_mem(A_handle, STARPU_R);	
+	starpu_data_acquire(A_handle, STARPU_R);	
 
 	/* Check result */
 	unsigned i;
@@ -94,7 +94,7 @@ int main(int argc, char **argv)
 		STARPU_ASSERT(A[i] == NLOOPS);
 	}
 
-	starpu_data_release_from_mem(A_handle);
+	starpu_data_release(A_handle);
 
 	starpu_shutdown();
 

tests/datawizard/sync_and_notify_data.c

@@ -130,12 +130,12 @@ int main(int argc, char **argv)
 		}
 
 		/* synchronize v in RAM */
-		starpu_data_sync_with_mem(v_handle, STARPU_RW);
+		starpu_data_acquire(v_handle, STARPU_RW);
 
 		/* increment b */
 		v[1]++;
 
-		starpu_data_release_from_mem(v_handle);
+		starpu_data_release(v_handle);
 
 		for (ind = 0; ind < N; ind++)
 		{
@@ -170,11 +170,11 @@ int main(int argc, char **argv)
 
 	}
 
-	starpu_data_sync_with_mem(v_handle, STARPU_RW);
+	starpu_data_acquire(v_handle, STARPU_RW);
 
 	fprintf(stderr, "V = { %d, %d, %d }\n", v[0], v[1], v[2]);
 
-	starpu_data_release_from_mem(v_handle);
+	starpu_data_release(v_handle);
 
 	starpu_shutdown();
 

tests/datawizard/sync_and_notify_data_implicit.c

@@ -146,12 +146,12 @@ int main(int argc, char **argv)
 		}
 
 		/* synchronize v in RAM */
-		starpu_data_sync_with_mem(v_handle, STARPU_RW);
+		starpu_data_acquire(v_handle, STARPU_RW);
 
 		/* increment b */
 		v[1]++;
 
-		starpu_data_release_from_mem(v_handle);
+		starpu_data_release(v_handle);
 
 		for (ind = 0; ind < N; ind++)
 		{
@@ -168,11 +168,11 @@ int main(int argc, char **argv)
 
 	}
 
-	starpu_data_sync_with_mem(v_handle, STARPU_RW);
+	starpu_data_acquire(v_handle, STARPU_RW);
 
 	fprintf(stderr, "V = { %d, %d, %d }\n", v[0], v[1], v[2]);
 
-	starpu_data_release_from_mem(v_handle);
+	starpu_data_release(v_handle);
 
 	starpu_shutdown();
 

tests/datawizard/sync_with_data_with_mem.c

@@ -89,11 +89,11 @@ int main(int argc, char **argv)
 
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < NBUFFERS; b++)
-			starpu_data_sync_with_mem(v_handle[b], STARPU_RW);
+			starpu_data_acquire(v_handle[b], STARPU_RW);
 
 		/* Release them */
 		for (b = 0; b < NBUFFERS; b++)
-			starpu_data_release_from_mem(v_handle[b]);
+			starpu_data_release(v_handle[b]);
 	}
 
 	/* do some cleanup */

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -112,7 +112,7 @@ int main(int argc, char **argv)
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < NBUFFERS; b++)
 		{
-			starpu_data_sync_with_mem_non_blocking(v_handle[b], STARPU_RW,
+			starpu_data_acquire_cb(v_handle[b], STARPU_RW,
 					callback_sync_data, NULL);
 		}
 
@@ -126,7 +126,7 @@ int main(int argc, char **argv)
 
 		/* Release them */
 		for (b = 0; b < NBUFFERS; b++)
-			starpu_data_release_from_mem(v_handle[b]);
+			starpu_data_release(v_handle[b]);
 	}
 
 	/* do some cleanup */

tests/datawizard/sync_with_data_with_mem_non_blocking_implicit.c

@@ -109,7 +109,7 @@ int main(int argc, char **argv)
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < NBUFFERS; b++)
 		{
-			starpu_data_sync_with_mem_non_blocking(v_handle[b], STARPU_RW,
+			starpu_data_acquire_cb(v_handle[b], STARPU_RW,
 					callback_sync_data, NULL);
 		}
 
@@ -123,7 +123,7 @@ int main(int argc, char **argv)
 
 		/* Release them */
 		for (b = 0; b < NBUFFERS; b++)
-			starpu_data_release_from_mem(v_handle[b]);
+			starpu_data_release(v_handle[b]);
 	}
 
 	starpu_task_wait_for_all();

tests/datawizard/user_interaction_implicit.c

@@ -38,7 +38,7 @@ void callback_sync_data(void *arg)
 
 	data->val++;
 
-	starpu_data_release_from_mem(data->handle);
+	starpu_data_release(data->handle);
 }
 
 int main(int argc, char **argv)
@@ -56,7 +56,7 @@ int main(int argc, char **argv)
 	for (iter = 0; iter < NITER; iter++)
 	for (b = 0; b < NBUFFERS; b++)
 	{
-		starpu_data_sync_with_mem_non_blocking(buffers[b].handle, STARPU_RW,
+		starpu_data_acquire_cb(buffers[b].handle, STARPU_RW,
 							callback_sync_data, &buffers[b]);
 	}
 

tests/errorcheck/invalid_blocking_calls.c

@@ -27,7 +27,7 @@ static void wrong_func(void *descr[], void *arg)
 
 	/* try to fetch data in the RAM while we are in a codelet, such a
 	 * blocking call is forbidden */
-	ret = starpu_data_sync_with_mem(handle, STARPU_RW);
+	ret = starpu_data_acquire(handle, STARPU_RW);
 	if (ret != -EDEADLK)
 		exit(-1);
 
@@ -50,7 +50,7 @@ static void wrong_callback(void *arg)
 {
 	int ret;
 
-	ret  = starpu_data_sync_with_mem(handle, STARPU_RW);
+	ret  = starpu_data_acquire(handle, STARPU_RW);
 	if (ret != -EDEADLK)
 		exit(-1);
 
@@ -91,11 +91,11 @@ int main(int argc, char **argv)
 
 	/* This call is valid as it is done by the application outside a
 	 * callback */
-	ret = starpu_data_sync_with_mem(handle, STARPU_RW);
+	ret = starpu_data_acquire(handle, STARPU_RW);
 	if (ret)
 		return -1;
 
-	starpu_data_release_from_mem(handle);
+	starpu_data_release(handle);
 
 	starpu_shutdown();