Prefixing of src/datawizard/data_request.h ...

find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_t\b"/starpu_data_request_t/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_new\b"/starpu_data_request_new/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_delete\b"/starpu_data_request_delete/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_new\b"/starpu_data_request_list_new/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_delete\b"/starpu_data_request_list_delete/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_empty\b"/starpu_data_request_list_empty/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_erase\b"/starpu_data_request_list_erase/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_push_back\b"/starpu_data_request_list_push_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_push_front\b"/starpu_data_request_list_push_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_pop_back\b"/starpu_data_request_list_pop_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_pop_front\b"/starpu_data_request_list_pop_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_back\b"/starpu_data_request_list_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_front\b"/starpu_data_request_list_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_check\b"/starpu_data_request_list_check/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_list_t\b"/starpu_data_request_list_t/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_request_itor_t\b"/starpu_data_request_itor_t/g

find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_t\b"/starpu_data_requester_t/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_new\b"/starpu_data_requester_new/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_delete\b"/starpu_data_requester_delete/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_new\b"/starpu_data_requester_list_new/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_delete\b"/starpu_data_requester_list_delete/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_empty\b"/starpu_data_requester_list_empty/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_erase\b"/starpu_data_requester_list_erase/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_push_back\b"/starpu_data_requester_list_push_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_push_front\b"/starpu_data_requester_list_push_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_pop_back\b"/starpu_data_requester_list_pop_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_pop_front\b"/starpu_data_requester_list_pop_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_back\b"/starpu_data_requester_list_back/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_front\b"/starpu_data_requester_list_front/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_check\b"/starpu_data_requester_list_check/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_t\b"/starpu_data_requester_list_t/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_itor_t\b"/starpu_data_requester_itor_t/g

find . -type f -not -name "*svn*"|xargs sed -i s/"\binit_data_request_lists\b"/starpu_init_data_request_lists/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdeinit_data_request_lists\b"/starpu_deinit_data_request_lists/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bpost_data_request\b"/starpu_post_data_request/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bhandle_node_data_requests\b"/starpu_handle_node_data_requests/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bhandle_pending_node_data_requests\b"/starpu_handle_pending_node_data_requests/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bhandle_all_pending_node_data_requests\b"/starpu_handle_all_pending_node_data_requests/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bcheck_that_no_data_request_exists\b"/starpu_check_that_no_data_request_exists/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bcreate_data_request\b"/starpu_create_data_request/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bsearch_existing_data_request\b"/starpu_search_existing_data_request/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bwait_data_request_completion\b"/starpu_wait_data_request_completion/g

src/core/dependencies/data-concurrency.c

@@ -21,7 +21,7 @@
 
 static unsigned _submit_job_enforce_data_deps(job_t j, unsigned start_buffer_index);
 
-static unsigned unlock_one_requester(data_requester_t r)
+static unsigned unlock_one_requester(starpu_data_requester_t r)
 {
 	job_t j = r->j;
 	unsigned nbuffers = j->task->cl->nbuffers;
@@ -40,7 +40,7 @@ static unsigned unlock_one_requester(data_requester_t r)
 static unsigned may_unlock_data_req_list_head(starpu_data_handle handle)
 {
 	/* if there is no one to unlock ... */
-	if (data_requester_list_empty(handle->req_list))
+	if (starpu_data_requester_list_empty(handle->req_list))
 		return 0;
 
 	/* if there is no reference to the data anymore, we can use it */
@@ -55,7 +55,7 @@ static unsigned may_unlock_data_req_list_head(starpu_data_handle handle)
 		return 0;
 
 	/* data->current_mode == STARPU_R, so we can process more readers */
-	data_requester_t r = data_requester_list_front(handle->req_list);
+	starpu_data_requester_t r = starpu_data_requester_list_front(handle->req_list);
 	
 	return (r->mode == STARPU_R);
 }
@@ -93,13 +93,13 @@ unsigned attempt_to_submit_data_request_from_apps(starpu_data_handle handle, sta
 			 * while the data is in read mode */
 			
 			/* enqueue the request */
-			data_requester_t r = data_requester_new();
+			starpu_data_requester_t r = starpu_data_requester_new();
 				r->mode = mode;
 				r->is_requested_by_codelet = 0;
 				r->ready_data_callback = callback;
 				r->argcb = argcb;
 
-			data_requester_list_push_back(handle->req_list, r);
+			starpu_data_requester_list_push_back(handle->req_list, r);
 
 			/* failed */
 			ret = 1;
@@ -145,13 +145,13 @@ static unsigned attempt_to_submit_data_request_from_job(job_t j, unsigned buffer
 			 * while the data is in read mode */
 			
 			/* enqueue the request */
-			data_requester_t r = data_requester_new();
+			starpu_data_requester_t r = starpu_data_requester_new();
 				r->mode = mode;
 				r->is_requested_by_codelet = 1;
 				r->j = j;
 				r->buffer_index = buffer_index;
 
-			data_requester_list_push_back(handle->req_list, r);
+			starpu_data_requester_list_push_back(handle->req_list, r);
 
 			/* failed */
 			ret = 1;
@@ -199,7 +199,7 @@ void notify_data_dependencies(starpu_data_handle handle)
 	while (may_unlock_data_req_list_head(handle))
 	{
 		/* unlock the head of the requester list */
-		data_requester_t r = data_requester_list_pop_front(handle->req_list);
+		starpu_data_requester_t r = starpu_data_requester_list_pop_front(handle->req_list);
 
 		handle->refcnt++;
 	
@@ -221,7 +221,7 @@ void notify_data_dependencies(starpu_data_handle handle)
 			r->ready_data_callback(r->argcb);
 		}
 
-		data_requester_delete(r);
+		starpu_data_requester_delete(r);
 		
 		starpu_spin_lock(&handle->header_lock);
 	}

src/core/policies/sched_policy.c

@@ -256,7 +256,7 @@ void wait_on_sched_event(void)
 
 	pthread_mutex_lock(&q->activity_mutex);
 
-	handle_all_pending_node_data_requests(get_local_memory_node());
+	starpu_handle_all_pending_node_data_requests(get_local_memory_node());
 
 	if (_starpu_machine_is_running())
 	{

src/core/workers.c

@@ -312,7 +312,7 @@ unsigned _starpu_worker_can_block(unsigned memnode)
 {
 	unsigned can_block = 1;
 
-	if (!check_that_no_data_request_exists(memnode))
+	if (!starpu_check_that_no_data_request_exists(memnode))
 		can_block = 0;
 
 	if (!_starpu_machine_is_running())

src/datawizard/coherency.c

@@ -163,11 +163,11 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 
 	msi_cache_miss(requesting_node);
 
-	data_request_t r;
+	starpu_data_request_t r;
 
 	/* is there already a pending request ? */
-	r = search_existing_data_request(handle, requesting_node, read, write);
-	/* at the exit of search_existing_data_request the lock is taken is the request existed ! */
+	r = starpu_search_existing_data_request(handle, requesting_node, read, write);
+	/* at the exit of starpu_search_existing_data_request the lock is taken is the request existed ! */
 
 	if (!r) {
 		//fprintf(stderr, "no request matched that one so we post a request %s\n", is_prefetch?"STARPU_PREFETCH":"");
@@ -187,20 +187,20 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 		/* we have to perform 2 successive requests for GPU->GPU transfers */
 		if (read && (src_is_a_gpu && dst_is_a_gpu)) {
 			unsigned reuse_r_src_to_ram;
-			data_request_t r_src_to_ram;
-			data_request_t r_ram_to_dst;
+			starpu_data_request_t r_src_to_ram;
+			starpu_data_request_t r_ram_to_dst;
 
 			/* XXX we hardcore 0 as the RAM node ... */
-			r_ram_to_dst = create_data_request(handle, 0, requesting_node, requesting_node, read, write, is_prefetch);
+			r_ram_to_dst = starpu_create_data_request(handle, 0, requesting_node, requesting_node, read, write, is_prefetch);
 
 			if (!is_prefetch)
 				r_ram_to_dst->refcnt++;
 
-			r_src_to_ram = search_existing_data_request(handle, 0, read, write);
+			r_src_to_ram = starpu_search_existing_data_request(handle, 0, read, write);
 			if (!r_src_to_ram)
 			{
 				reuse_r_src_to_ram = 0;
-				r_src_to_ram = create_data_request(handle, src_node, 0, src_node, read, write, is_prefetch);
+				r_src_to_ram = starpu_create_data_request(handle, src_node, 0, src_node, read, write, is_prefetch);
 			}
 			else {
 				reuse_r_src_to_ram = 1;
@@ -216,7 +216,7 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 
 			/* we only submit the first request, the remaining will be automatically submitted afterward */
 			if (!reuse_r_src_to_ram)
-				post_data_request(r_src_to_ram, src_node);
+				starpu_post_data_request(r_src_to_ram, src_node);
 
 			/* the application only waits for the termination of the last request */
 			r = r_ram_to_dst;
@@ -226,18 +226,18 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 			uint32_t handling_node =
 				starpu_select_node_to_handle_request(src_node, requesting_node);
 
-			r = create_data_request(handle, src_node, requesting_node, handling_node, read, write, is_prefetch);
+			r = starpu_create_data_request(handle, src_node, requesting_node, handling_node, read, write, is_prefetch);
 
 			if (!is_prefetch)
 				r->refcnt++;
 
 			starpu_spin_unlock(&handle->header_lock);
 
-			post_data_request(r, handling_node);
+			starpu_post_data_request(r, handling_node);
 		}
 	}
 	else {
-		/* the lock was taken by search_existing_data_request */
+		/* the lock was taken by starpu_search_existing_data_request */
 
 		/* there is already a similar request */
 		if (is_prefetch)
@@ -266,7 +266,7 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 		starpu_spin_unlock(&handle->header_lock);
 	}
 
-	return (is_prefetch?0:wait_data_request_completion(r, 1));
+	return (is_prefetch?0:starpu_wait_data_request_completion(r, 1));
 }
 
 static int prefetch_data_on_node(starpu_data_handle handle, uint8_t read, uint8_t write, uint32_t node)

src/datawizard/data_request.c

@@ -19,57 +19,57 @@
 #include <pthread.h>
 
 /* requests that have not been treated at all */
-static data_request_list_t data_requests[STARPU_MAXNODES];
+static starpu_data_request_list_t data_requests[STARPU_MAXNODES];
 static pthread_cond_t data_requests_list_cond[STARPU_MAXNODES];
 static pthread_mutex_t data_requests_list_mutex[STARPU_MAXNODES];
 
 /* requests that are not terminated (eg. async transfers) */
-static data_request_list_t data_requests_pending[STARPU_MAXNODES];
+static starpu_data_request_list_t data_requests_pending[STARPU_MAXNODES];
 static pthread_cond_t data_requests_pending_list_cond[STARPU_MAXNODES];
 static pthread_mutex_t data_requests_pending_list_mutex[STARPU_MAXNODES];
 
-void init_data_request_lists(void)
+void starpu_init_data_request_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
-		data_requests[i] = data_request_list_new();
+		data_requests[i] = starpu_data_request_list_new();
 		pthread_mutex_init(&data_requests_list_mutex[i], NULL);
 		pthread_cond_init(&data_requests_list_cond[i], NULL);
 
-		data_requests_pending[i] = data_request_list_new();
+		data_requests_pending[i] = starpu_data_request_list_new();
 		pthread_mutex_init(&data_requests_pending_list_mutex[i], NULL);
 		pthread_cond_init(&data_requests_pending_list_cond[i], NULL);
 	}
 }
 
-void deinit_data_request_lists(void)
+void starpu_deinit_data_request_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
 		pthread_cond_destroy(&data_requests_pending_list_cond[i]);
 		pthread_mutex_destroy(&data_requests_pending_list_mutex[i]);
-		data_request_list_delete(data_requests_pending[i]);
+		starpu_data_request_list_delete(data_requests_pending[i]);
 
 		pthread_cond_destroy(&data_requests_list_cond[i]);
 		pthread_mutex_destroy(&data_requests_list_mutex[i]);
-		data_request_list_delete(data_requests[i]);
+		starpu_data_request_list_delete(data_requests[i]);
 	}
 }
 
 /* this should be called with the lock r->handle->header_lock taken */
-static void data_request_destroy(data_request_t r)
+static void starpu_data_request_destroy(starpu_data_request_t r)
 {
 	r->handle->per_node[r->dst_node].request = NULL;
 
-	data_request_delete(r);
+	starpu_data_request_delete(r);
 }
 
 /* handle->lock should already be taken !  */
-data_request_t create_data_request(starpu_data_handle handle, uint32_t src_node, uint32_t dst_node, uint32_t handling_node, uint8_t read, uint8_t write, unsigned is_prefetch)
+starpu_data_request_t starpu_create_data_request(starpu_data_handle handle, uint32_t src_node, uint32_t dst_node, uint32_t handling_node, uint8_t read, uint8_t write, unsigned is_prefetch)
 {
-	data_request_t r = data_request_new();
+	starpu_data_request_t r = starpu_data_request_new();
 
 	starpu_spin_init(&r->lock);
 
@@ -109,9 +109,9 @@ data_request_t create_data_request(starpu_data_handle handle, uint32_t src_node,
 }
 
 /* handle->lock should be taken */
-data_request_t search_existing_data_request(starpu_data_handle handle, uint32_t dst_node, uint8_t read, uint8_t write)
+starpu_data_request_t starpu_search_existing_data_request(starpu_data_handle handle, uint32_t dst_node, uint8_t read, uint8_t write)
 {
-	data_request_t r = handle->per_node[dst_node].request;
+	starpu_data_request_t r = handle->per_node[dst_node].request;
 
 	if (r)
 	{
@@ -136,7 +136,7 @@ data_request_t search_existing_data_request(starpu_data_handle handle, uint32_t
 	return r;
 }
 
-int wait_data_request_completion(data_request_t r, unsigned may_alloc)
+int starpu_wait_data_request_completion(starpu_data_request_t r, unsigned may_alloc)
 {
 	int retval;
 	int do_delete = 0;
@@ -172,13 +172,13 @@ int wait_data_request_completion(data_request_t r, unsigned may_alloc)
 	starpu_spin_unlock(&r->lock);
 	
 	if (do_delete)
-		data_request_destroy(r);
+		starpu_data_request_destroy(r);
 	
 	return retval;
 }
 
 /* this is non blocking */
-void post_data_request(data_request_t r, uint32_t handling_node)
+void starpu_post_data_request(starpu_data_request_t r, uint32_t handling_node)
 {
 	int res;
 //	fprintf(stderr, "POST REQUEST\n");
@@ -193,7 +193,7 @@ void post_data_request(data_request_t r, uint32_t handling_node)
 	res = pthread_mutex_lock(&data_requests_list_mutex[handling_node]);
 	STARPU_ASSERT(!res);
 
-	data_request_list_push_front(data_requests[handling_node], r);
+	starpu_data_request_list_push_front(data_requests[handling_node], r);
 
 	res = pthread_mutex_unlock(&data_requests_list_mutex[handling_node]);
 	STARPU_ASSERT(!res);
@@ -201,7 +201,7 @@ void post_data_request(data_request_t r, uint32_t handling_node)
 	_starpu_wake_all_blocked_workers_on_node(handling_node);
 }
 
-static void handle_data_request_completion(data_request_t r)
+static void starpu_handle_data_request_completion(starpu_data_request_t r)
 {
 	unsigned do_delete = 0;
 	starpu_data_handle handle = r->handle;
@@ -219,7 +219,7 @@ static void handle_data_request_completion(data_request_t r)
 	unsigned chained_req;
 	for (chained_req = 0; chained_req < r->next_req_count; chained_req++)
 	{
-		post_data_request(r->next_req[chained_req], r->next_req[chained_req]->handling_node);
+		starpu_post_data_request(r->next_req[chained_req], r->next_req[chained_req]->handling_node);
 	}
 
 	r->completed = 1;
@@ -240,13 +240,13 @@ static void handle_data_request_completion(data_request_t r)
 	starpu_spin_unlock(&r->lock);
 
 	if (do_delete)
-		data_request_destroy(r);
+		starpu_data_request_destroy(r);
 
 	starpu_spin_unlock(&handle->header_lock);
 }
 
 /* TODO : accounting to see how much time was spent working for other people ... */
-static int handle_data_request(data_request_t r, unsigned may_alloc)
+static int starpu_handle_data_request(starpu_data_request_t r, unsigned may_alloc)
 {
 	starpu_data_handle handle = r->handle;
 
@@ -279,32 +279,32 @@ static int handle_data_request(data_request_t r, unsigned may_alloc)
 
 		/* the request is pending and we put it in the corresponding queue  */
 		pthread_mutex_lock(&data_requests_pending_list_mutex[r->handling_node]);
-		data_request_list_push_front(data_requests_pending[r->handling_node], r);
+		starpu_data_request_list_push_front(data_requests_pending[r->handling_node], r);
 		pthread_mutex_unlock(&data_requests_pending_list_mutex[r->handling_node]);
 
 		return EAGAIN;
 	}
 
 	/* the request has been handled */
-	handle_data_request_completion(r);
+	starpu_handle_data_request_completion(r);
 
 	return 0;
 }
 
-void handle_node_data_requests(uint32_t src_node, unsigned may_alloc)
+void starpu_handle_node_data_requests(uint32_t src_node, unsigned may_alloc)
 {
 	int res;
 
 	/* for all entries of the list */
-	data_request_t r;
+	starpu_data_request_t r;
 
 	/* take all the entries from the request list */
 	res = pthread_mutex_lock(&data_requests_list_mutex[src_node]);
 	STARPU_ASSERT(!res);
 
-	data_request_list_t local_list = data_requests[src_node];
+	starpu_data_request_list_t local_list = data_requests[src_node];
 
-	if (data_request_list_empty(local_list))
+	if (starpu_data_request_list_empty(local_list))
 	{
 		/* there is no request */
 		res = pthread_mutex_unlock(&data_requests_list_mutex[src_node]);
@@ -313,22 +313,22 @@ void handle_node_data_requests(uint32_t src_node, unsigned may_alloc)
 		return;
 	}
 
-	data_requests[src_node] = data_request_list_new();
+	data_requests[src_node] = starpu_data_request_list_new();
 
 	res = pthread_mutex_unlock(&data_requests_list_mutex[src_node]);
 	STARPU_ASSERT(!res);
 
-	while (!data_request_list_empty(local_list))
+	while (!starpu_data_request_list_empty(local_list))
 	{
-		r = data_request_list_pop_back(local_list);
+		r = starpu_data_request_list_pop_back(local_list);
 
-		res = handle_data_request(r, may_alloc);
+		res = starpu_handle_data_request(r, may_alloc);
 		if (res == ENOMEM)
 		{
 			res = pthread_mutex_lock(&data_requests_list_mutex[src_node]);
 			STARPU_ASSERT(!res);
 
-			data_request_list_push_front(data_requests[src_node], r);
+			starpu_data_request_list_push_front(data_requests[src_node], r);
 
 			res = pthread_mutex_unlock(&data_requests_list_mutex[src_node]);
 			STARPU_ASSERT(!res);
@@ -339,28 +339,28 @@ void handle_node_data_requests(uint32_t src_node, unsigned may_alloc)
 		// pthread_cond_broadcast(&data_requests_list_cond[src_node]);
 	}
 
-	data_request_list_delete(local_list);
+	starpu_data_request_list_delete(local_list);
 }
 
 static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force)
 {
 	int res;
-//	fprintf(stderr, "handle_pending_node_data_requests ...\n");
+//	fprintf(stderr, "starpu_handle_pending_node_data_requests ...\n");
 
 	res = pthread_mutex_lock(&data_requests_pending_list_mutex[src_node]);
 	STARPU_ASSERT(!res);
 
 	/* for all entries of the list */
-	data_request_list_t local_list = data_requests_pending[src_node];
-	data_requests_pending[src_node] = data_request_list_new();
+	starpu_data_request_list_t local_list = data_requests_pending[src_node];
+	data_requests_pending[src_node] = starpu_data_request_list_new();
 
 	res = pthread_mutex_unlock(&data_requests_pending_list_mutex[src_node]);
 	STARPU_ASSERT(!res);
 
-	while (!data_request_list_empty(local_list))
+	while (!starpu_data_request_list_empty(local_list))
 	{
-		data_request_t r;
-		r = data_request_list_pop_back(local_list);
+		starpu_data_request_t r;
+		r = starpu_data_request_list_pop_back(local_list);
 
 		starpu_data_handle handle = r->handle;
 		
@@ -372,13 +372,13 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 		if (force)
 		{
 			starpu_driver_wait_request_completion(&r->async_channel, src_node);
-			handle_data_request_completion(r);
+			starpu_handle_data_request_completion(r);
 		}
 		else {
 			if (starpu_driver_test_request_completion(&r->async_channel, src_node))
 			{
 				
-				handle_data_request_completion(r);
+				starpu_handle_data_request_completion(r);
 			}
 			else {
 				starpu_spin_unlock(&r->lock);
@@ -386,30 +386,30 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 
 				/* wake the requesting worker up */
 				pthread_mutex_lock(&data_requests_pending_list_mutex[src_node]);
-				data_request_list_push_front(data_requests_pending[src_node], r);
+				starpu_data_request_list_push_front(data_requests_pending[src_node], r);
 				pthread_mutex_unlock(&data_requests_pending_list_mutex[src_node]);
 			}
 		}
 	}
 
-	data_request_list_delete(local_list);
+	starpu_data_request_list_delete(local_list);
 }
 
-void handle_pending_node_data_requests(uint32_t src_node)
+void starpu_handle_pending_node_data_requests(uint32_t src_node)
 {
 	_handle_pending_node_data_requests(src_node, 0);
 }
 
-void handle_all_pending_node_data_requests(uint32_t src_node)
+void starpu_handle_all_pending_node_data_requests(uint32_t src_node)
 {
 	_handle_pending_node_data_requests(src_node, 1);
 }
 
-int check_that_no_data_request_exists(uint32_t node)
+int starpu_check_that_no_data_request_exists(uint32_t node)
 {
 	/* XXX lock that !!! that's a quick'n'dirty test */
-	int no_request = data_request_list_empty(data_requests[node]);
-	int no_pending = data_request_list_empty(data_requests_pending[node]);
+	int no_request = starpu_data_request_list_empty(data_requests[node]);
+	int no_pending = starpu_data_request_list_empty(data_requests_pending[node]);
 
 	return (no_request && no_pending);
 }

src/datawizard/data_request.h

@@ -26,7 +26,7 @@
 #define DATA_REQ_ALLOCATE	(1<<0)
 #define DATA_REQ_COPY		(1<<1)
 
-LIST_TYPE(data_request,
+LIST_TYPE(starpu_data_request,
 	starpu_spinlock_t lock;
 	unsigned refcnt;
 
@@ -64,7 +64,7 @@ LIST_TYPE(data_request,
 
 /* Everyone that wants to access some piece of data will post a request.
  * Not only StarPU internals, but also the application may put such requests */
-LIST_TYPE(data_requester,
+LIST_TYPE(starpu_data_requester,
 	/* what kind of access is requested ? */
 	starpu_access_mode mode;
 
@@ -82,18 +82,18 @@ LIST_TYPE(data_requester,
 	void *argcb;
 );
 
-void init_data_request_lists(void);
-void deinit_data_request_lists(void);
-void post_data_request(data_request_t r, uint32_t handling_node);
-void handle_node_data_requests(uint32_t src_node, unsigned may_alloc);
+void starpu_init_data_request_lists(void);
+void starpu_deinit_data_request_lists(void);
+void starpu_post_data_request(starpu_data_request_t r, uint32_t handling_node);
+void starpu_handle_node_data_requests(uint32_t src_node, unsigned may_alloc);
 
-void handle_pending_node_data_requests(uint32_t src_node);
-void handle_all_pending_node_data_requests(uint32_t src_node);
+void starpu_handle_pending_node_data_requests(uint32_t src_node);
+void starpu_handle_all_pending_node_data_requests(uint32_t src_node);
 
-int check_that_no_data_request_exists(uint32_t node);
+int starpu_check_that_no_data_request_exists(uint32_t node);
 
-data_request_t create_data_request(starpu_data_handle handle, uint32_t src_node, uint32_t dst_node, uint32_t handling_node, uint8_t read, uint8_t write, unsigned is_prefetch);
-data_request_t search_existing_data_request(starpu_data_handle handle, uint32_t dst_node, uint8_t read, uint8_t write);
-int wait_data_request_completion(data_request_t r, unsigned may_alloc);
+starpu_data_request_t starpu_create_data_request(starpu_data_handle handle, uint32_t src_node, uint32_t dst_node, uint32_t handling_node, uint8_t read, uint8_t write, unsigned is_prefetch);
+starpu_data_request_t starpu_search_existing_data_request(starpu_data_handle handle, uint32_t dst_node, uint8_t read, uint8_t write);
+int starpu_wait_data_request_completion(starpu_data_request_t r, unsigned may_alloc);
 
 #endif // __DATA_REQUEST_H__

src/datawizard/hierarchy.c

@@ -43,7 +43,7 @@ void starpu_delete_data(starpu_data_handle handle)
 		}
 	}
 
-	data_requester_list_delete(handle->req_list);
+	starpu_data_requester_list_delete(handle->req_list);
 
 	starpu_data_liberate_interfaces(handle);
 
@@ -55,7 +55,7 @@ void register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t w
 	STARPU_ASSERT(handle);
 
 	/* initialize the new lock */
-	handle->req_list = data_requester_list_new();
+	handle->req_list = starpu_data_requester_list_new();
 	handle->refcnt = 0;
 	starpu_spin_init(&handle->header_lock);
 
@@ -202,7 +202,7 @@ void starpu_partition_data(starpu_data_handle initial_handle, starpu_filter *f)
 		children->wb_mask = initial_handle->wb_mask;
 
 		/* initialize the chunk lock */
-		children->req_list = data_requester_list_new();
+		children->req_list = starpu_data_requester_list_new();
 		children->refcnt = 0;
 		starpu_spin_init(&children->header_lock);
 

src/datawizard/memory_nodes.c

@@ -38,7 +38,7 @@ void init_memory_nodes(void)
 		descr.nodes[i] = UNUSED; 
 
 	_starpu_init_mem_chunk_lists();
-	init_data_request_lists();
+	starpu_init_data_request_lists();
 
 	pthread_rwlock_init(&descr.attached_queues_rwlock, NULL);
 	descr.total_queues_count = 0;
@@ -46,7 +46,7 @@ void init_memory_nodes(void)
 
 void deinit_memory_nodes(void)
 {
-	deinit_data_request_lists();
+	starpu_deinit_data_request_lists();
 	_starpu_deinit_mem_chunk_lists();
 
 	pthread_key_delete(memory_node_key);

src/datawizard/progress.c

@@ -22,8 +22,8 @@
 void _starpu_datawizard_progress(uint32_t memory_node, unsigned may_alloc)
 {
 	/* in case some other driver requested data */
-	handle_pending_node_data_requests(memory_node);
-	handle_node_data_requests(memory_node, may_alloc);
+	starpu_handle_pending_node_data_requests(memory_node);
+	starpu_handle_node_data_requests(memory_node, may_alloc);
 
 	_starpu_execute_registered_progression_hooks();
 }

src/datawizard/user_interactions.c

@@ -22,16 +22,16 @@
 
 int starpu_request_data_allocation(starpu_data_handle handle, uint32_t node)
 {
-	data_request_t r;
+	starpu_data_request_t r;
 
 	STARPU_ASSERT(handle);
 
-	r = create_data_request(handle, 0, node, node, 0, 0, 1);
+	r = starpu_create_data_request(handle, 0, node, node, 0, 0, 1);
 
 	/* we do not increase the refcnt associated to the request since we are
 	 * not waiting for its termination */
 
-	post_data_request(r, node);
+	starpu_post_data_request(r, node);
 
 	return 0;
 }

src/datawizard/write_back.c

@@ -39,16 +39,16 @@ void write_through_data(starpu_data_handle handle, uint32_t requesting_node,
 				uint32_t handling_node =
 					starpu_select_node_to_handle_request(requesting_node, node);
 
-				data_request_t r;
+				starpu_data_request_t r;
 
 				/* check that there is not already a similar
 				 * request that we should reuse */
-				r = search_existing_data_request(handle, node, 1, 0);
+				r = starpu_search_existing_data_request(handle, node, 1, 0);
 				if (!r) {
 					/* there was no existing request so we create one now */
-					r = create_data_request(handle, requesting_node,
+					r = starpu_create_data_request(handle, requesting_node,
 							node, handling_node, 1, 0, 1);
-					post_data_request(r, handling_node);
+					starpu_post_data_request(r, handling_node);
 				}
 				else {
 					/* if there is already a similar request, it is