Prefixing in src/datawizard/coherency.h ...

find . -type f -not -name "*svn*"|xargs sed -i s/"\bcache_state\b"/starpu_cache_state/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bOWNER\b"/STARPU_OWNER/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bSHARED\b"/STARPU_SHARED/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bINVALID\b"/STARPU_INVALID/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\blocal_data_state_t\b"/starpu_local_data_state_t/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\blocal_data_state\b"/starpu_local_data_state/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdata_requester_list_s\b"/starpu_data_requester_list_s/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bdisplay_msi_stats\b"/starpu_display_msi_stats/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bfetch_data_on_node\b"/starpu_fetch_data_on_node/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\brelease_data_on_node\b"/starpu_release_data_on_node/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bupdate_data_state\b"/starpu_update_data_state/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bget_data_refcnt\b"/starpu_get_data_refcnt/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bpush_task_output\b"/starpu_push_task_output/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bis_data_present_or_requested\b"/starpu_is_data_present_or_requested/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bset_data_requested_flag_if_needed\b"/starpu_set_data_requested_flag_if_needed/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bprefetch_task_input_on_node\b"/starpu_prefetch_task_input_on_node/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bselect_node_to_handle_request\b"/starpu_select_node_to_handle_request/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bselect_src_node\b"/starpu_select_src_node/g

src/core/perfmodel/perfmodel.c

@@ -130,11 +130,11 @@ double data_expected_penalty(struct jobq_s *q, struct starpu_task *task)
 		if (task->buffers[buffer].mode == STARPU_W)
 			continue;
 
-		if (!is_data_present_or_requested(handle, memory_node))
+		if (!starpu_is_data_present_or_requested(handle, memory_node))
 		{
 			size_t size = handle->ops->get_size(handle);
 
-			uint32_t src_node = select_src_node(handle);
+			uint32_t src_node = starpu_select_src_node(handle);
 
 			penalty += predict_transfer_time(src_node, memory_node, size);
 		}

src/core/policies/deque-modeling-policy-data-aware.c

@@ -51,7 +51,7 @@ static void update_data_requests(struct jobq_s *q, struct starpu_task *task)
 	{
 		starpu_data_handle handle = task->buffers[buffer].handle;
 
-		set_data_requested_flag_if_needed(handle, memory_node);
+		starpu_set_data_requested_flag_if_needed(handle, memory_node);
 	}
 }
 
@@ -169,7 +169,7 @@ static int _dmda_push_task(struct jobq_s *q __attribute__ ((unused)) , job_t j,
 	update_data_requests(queue_array[best], task);
 	
 	if (use_prefetch)
-		prefetch_task_input_on_node(task, queue_array[best]->memory_node);
+		starpu_prefetch_task_input_on_node(task, queue_array[best]->memory_node);
 
 	if (prio) {
 		return fifo_push_prio_task(queue_array[best], j);

src/core/policies/deque-modeling-policy.c

@@ -130,7 +130,7 @@ static int _dm_push_task(struct jobq_s *q __attribute__ ((unused)), job_t j, uns
 	j->predicted = model_best;
 
 	if (use_prefetch)
-		prefetch_task_input_on_node(task, queue_array[best]->memory_node);
+		starpu_prefetch_task_input_on_node(task, queue_array[best]->memory_node);
 
 	if (prio) {
 		return fifo_push_prio_task(queue_array[best], j);

src/core/policies/sched_policy.c

@@ -205,7 +205,7 @@ int push_task(job_t j)
 		if (use_prefetch)
 		{
 			uint32_t memory_node = starpu_get_worker_memory_node(workerid); 
-			prefetch_task_input_on_node(task, memory_node);
+			starpu_prefetch_task_input_on_node(task, memory_node);
 		}
 
 		return _starpu_push_local_task(worker, j);

src/core/workers.c

@@ -429,7 +429,7 @@ static void _starpu_kill_all_workers(struct machine_config_s *config)
 
 void starpu_shutdown(void)
 {
-	display_msi_stats();
+	starpu_display_msi_stats();
 	display_alloc_cache_stats();
 
 	/* tell all workers to shutdown */

src/datawizard/coherency.c

@@ -20,7 +20,7 @@
 #include <datawizard/write_back.h>
 #include <core/dependencies/data-concurrency.h>
 
-uint32_t select_node_to_handle_request(uint32_t src_node, uint32_t dst_node) 
+uint32_t starpu_select_node_to_handle_request(uint32_t src_node, uint32_t dst_node) 
 {
 	/* in case one of the node is a GPU, it needs to perform the transfer,
 	 * if both of them are GPU, it's a bit more complicated (TODO !) */
@@ -43,20 +43,20 @@ uint32_t select_node_to_handle_request(uint32_t src_node, uint32_t dst_node)
 	return get_local_memory_node();
 }
 
-uint32_t select_src_node(starpu_data_handle handle)
+uint32_t starpu_select_src_node(starpu_data_handle handle)
 {
 	unsigned src_node = 0;
 	unsigned i;
 
 	unsigned nnodes = get_memory_nodes_count();
 
-	/* first find a valid copy, either a OWNER or a SHARED */
+	/* first find a valid copy, either a STARPU_OWNER or a STARPU_SHARED */
 	uint32_t node;
 
 	uint32_t src_node_mask = 0;
 	for (node = 0; node < nnodes; node++)
 	{
-		if (handle->per_node[node].state != INVALID) {
+		if (handle->per_node[node].state != STARPU_INVALID) {
 			/* we found a copy ! */
 			src_node_mask |= (1<<node);
 		}
@@ -87,7 +87,7 @@ uint32_t select_src_node(starpu_data_handle handle)
 }
 
 /* this may be called once the data is fetched with header and STARPU_RW-lock hold */
-void update_data_state(starpu_data_handle handle, uint32_t requesting_node, uint8_t write)
+void starpu_update_data_state(starpu_data_handle handle, uint32_t requesting_node, uint8_t write)
 {
 	unsigned nnodes = get_memory_nodes_count();
 
@@ -98,21 +98,21 @@ void update_data_state(starpu_data_handle handle, uint32_t requesting_node, uint
 		/* the requesting node now has the only valid copy */
 		uint32_t node;
 		for (node = 0; node < nnodes; node++)
-			handle->per_node[node].state = INVALID;
+			handle->per_node[node].state = STARPU_INVALID;
 
-		handle->per_node[requesting_node].state = OWNER;
+		handle->per_node[requesting_node].state = STARPU_OWNER;
 	}
 	else { /* read only */
-		if (handle->per_node[requesting_node].state != OWNER)
+		if (handle->per_node[requesting_node].state != STARPU_OWNER)
 		{
 			/* there was at least another copy of the data */
 			uint32_t node;
 			for (node = 0; node < nnodes; node++)
 			{
-				if (handle->per_node[node].state != INVALID)
-					handle->per_node[node].state = SHARED;
+				if (handle->per_node[node].state != STARPU_INVALID)
+					handle->per_node[node].state = STARPU_SHARED;
 			}
-			handle->per_node[requesting_node].state = SHARED;
+			handle->per_node[requesting_node].state = STARPU_SHARED;
 		}
 	}
 }
@@ -138,7 +138,7 @@ void update_data_state(starpu_data_handle handle, uint32_t requesting_node, uint
  * 		    else (invalid,owner->shared)
  */
 
-int fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
+int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
 			uint8_t read, uint8_t write, unsigned is_prefetch)
 {
 	uint32_t local_node = get_local_memory_node();
@@ -149,17 +149,17 @@ int fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
 	if (!is_prefetch)
 		handle->per_node[requesting_node].refcnt++;
 
-	if (handle->per_node[requesting_node].state != INVALID)
+	if (handle->per_node[requesting_node].state != STARPU_INVALID)
 	{
 		/* the data is already available so we can stop */
-		update_data_state(handle, requesting_node, write);
+		starpu_update_data_state(handle, requesting_node, write);
 		msi_cache_hit(requesting_node);
 		starpu_spin_unlock(&handle->header_lock);
 		return 0;
 	}
 
 	/* the only remaining situation is that the local copy was invalid */
-	STARPU_ASSERT(handle->per_node[requesting_node].state == INVALID);
+	STARPU_ASSERT(handle->per_node[requesting_node].state == STARPU_INVALID);
 
 	msi_cache_miss(requesting_node);
 
@@ -177,7 +177,7 @@ int fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
 		/* if the data is in read only mode, there is no need for a source */
 		if (read)
 		{
-			src_node = select_src_node(handle);
+			src_node = starpu_select_src_node(handle);
 			STARPU_ASSERT(src_node != requesting_node);
 		}
 	
@@ -224,7 +224,7 @@ int fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
 		else {
 			/* who will perform that request ? */
 			uint32_t handling_node =
-				select_node_to_handle_request(src_node, requesting_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);
 
@@ -271,7 +271,7 @@ int fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_node,
 
 static int prefetch_data_on_node(starpu_data_handle handle, uint8_t read, uint8_t write, uint32_t node)
 {
-	return fetch_data_on_node(handle, node, read, write, 1);
+	return starpu_fetch_data_on_node(handle, node, read, write, 1);
 }
 
 static int fetch_data(starpu_data_handle handle, starpu_access_mode mode)
@@ -282,22 +282,22 @@ static int fetch_data(starpu_data_handle handle, starpu_access_mode mode)
 	read = (mode != STARPU_W); /* then R or STARPU_RW */
 	write = (mode != STARPU_R); /* then STARPU_W or STARPU_RW */
 
-	return fetch_data_on_node(handle, requesting_node, read, write, 0);
+	return starpu_fetch_data_on_node(handle, requesting_node, read, write, 0);
 }
 
-inline uint32_t get_data_refcnt(starpu_data_handle handle, uint32_t node)
+inline uint32_t starpu_get_data_refcnt(starpu_data_handle handle, uint32_t node)
 {
 	return handle->per_node[node].refcnt;
 }
 
 /* in case the data was accessed on a write mode, do not forget to 
  * make it accessible again once it is possible ! */
-void release_data_on_node(starpu_data_handle handle, uint32_t default_wb_mask, uint32_t memory_node)
+void starpu_release_data_on_node(starpu_data_handle handle, uint32_t default_wb_mask, uint32_t memory_node)
 {
 	uint32_t wb_mask;
 
 	/* normally, the requesting node should have the data in an exclusive manner */
-	STARPU_ASSERT(handle->per_node[memory_node].state != INVALID);
+	STARPU_ASSERT(handle->per_node[memory_node].state != STARPU_INVALID);
 
 	wb_mask = default_wb_mask | handle->wb_mask;
 
@@ -317,7 +317,7 @@ void release_data_on_node(starpu_data_handle handle, uint32_t default_wb_mask, u
 	starpu_spin_unlock(&handle->header_lock);
 }
 
-int prefetch_task_input_on_node(struct starpu_task *task, uint32_t node)
+int starpu_prefetch_task_input_on_node(struct starpu_task *task, uint32_t node)
 {
 	starpu_buffer_descr *descrs = task->buffers;
 	unsigned nbuffers = task->cl->nbuffers;
@@ -383,15 +383,15 @@ enomem:
 	/* XXX broken ... */
 	fprintf(stderr, "something went wrong with buffer %u\n", index);
 	//push_codelet_output(task, index, mask);
-	push_task_output(task, mask);
+	starpu_push_task_output(task, mask);
 	return -1;
 }
 
-void push_task_output(struct starpu_task *task, uint32_t mask)
+void starpu_push_task_output(struct starpu_task *task, uint32_t mask)
 {
 	TRACE_START_PUSH_OUTPUT(NULL);
 
-	//fprintf(stderr, "push_task_output\n");
+	//fprintf(stderr, "starpu_push_task_output\n");
 
         starpu_buffer_descr *descrs = task->buffers;
         unsigned nbuffers = task->cl->nbuffers;
@@ -401,7 +401,7 @@ void push_task_output(struct starpu_task *task, uint32_t mask)
 	unsigned index;
 	for (index = 0; index < nbuffers; index++)
 	{
-		release_data_on_node(descrs[index].handle, mask, local_node);
+		starpu_release_data_on_node(descrs[index].handle, mask, local_node);
 	}
 
 	TRACE_END_PUSH_OUTPUT(NULL);
@@ -409,14 +409,14 @@ void push_task_output(struct starpu_task *task, uint32_t mask)
 
 /* NB : this value can only be an indication of the status of a data
 	at some point, but there is no strong garantee ! */
-unsigned is_data_present_or_requested(starpu_data_handle handle, uint32_t node)
+unsigned starpu_is_data_present_or_requested(starpu_data_handle handle, uint32_t node)
 {
 	unsigned ret = 0;
 
 // XXX : this is just a hint, so we don't take the lock ...
 //	pthread_spin_lock(&handle->header_lock);
 
-	if (handle->per_node[node].state != INVALID 
+	if (handle->per_node[node].state != STARPU_INVALID 
 		|| handle->per_node[node].requested || handle->per_node[node].request)
 		ret = 1;
 
@@ -425,12 +425,12 @@ unsigned is_data_present_or_requested(starpu_data_handle handle, uint32_t node)
 	return ret;
 }
 
-inline void set_data_requested_flag_if_needed(starpu_data_handle handle, uint32_t node)
+inline void starpu_set_data_requested_flag_if_needed(starpu_data_handle handle, uint32_t node)
 {
 // XXX : this is just a hint, so we don't take the lock ...
 //	pthread_spin_lock(&handle->header_lock);
 
-	if (handle->per_node[node].state == INVALID) 
+	if (handle->per_node[node].state == STARPU_INVALID) 
 		handle->per_node[node].requested = 1;
 
 //	pthread_spin_unlock(&handle->header_lock);

src/datawizard/coherency.h

@@ -40,15 +40,15 @@
 #include <datawizard/datastats.h>
 
 typedef enum {
-	OWNER,
-	SHARED,
-	INVALID
-} cache_state;
+	STARPU_OWNER,
+	STARPU_SHARED,
+	STARPU_INVALID
+} starpu_cache_state;
 
 /* this should contain the information relative to a given node */
-typedef struct local_data_state_t {
+typedef struct starpu_local_data_state_t {
 	/* describes the state of the local data in term of coherency */
-	cache_state	state; 
+	starpu_cache_state	state; 
 
 	uint32_t refcnt;
 
@@ -69,12 +69,12 @@ typedef struct local_data_state_t {
 	 */
 	uint8_t requested;
 	struct data_request_s *request;
-} local_data_state;
+} starpu_local_data_state;
 
-struct data_requester_list_s;
+struct starpu_data_requester_list_s;
 
 struct starpu_data_state_t {
-	struct data_requester_list_s *req_list;
+	struct starpu_data_requester_list_s *req_list;
 	/* the number of requests currently in the scheduling engine
 	 * (not in the req_list anymore) */
 	unsigned refcnt;
@@ -87,7 +87,7 @@ struct starpu_data_state_t {
 	unsigned nchildren;
 
 	/* describe the state of the data in term of coherency */
-	local_data_state per_node[STARPU_MAXNODES];
+	starpu_local_data_state per_node[STARPU_MAXNODES];
 
 	/* describe the actual data layout */
 	void *interface[STARPU_MAXNODES];
@@ -108,28 +108,28 @@ struct starpu_data_state_t {
 	unsigned is_not_important;
 };
 
-void display_msi_stats(void);
+void starpu_display_msi_stats(void);
 
 __attribute__((warn_unused_result))
-int fetch_data_on_node(struct starpu_data_state_t *state, uint32_t requesting_node, uint8_t read, uint8_t write, unsigned is_prefetch);
-void release_data_on_node(struct starpu_data_state_t *state, uint32_t default_wb_mask, unsigned memory_node);
+int starpu_fetch_data_on_node(struct starpu_data_state_t *state, uint32_t requesting_node, uint8_t read, uint8_t write, unsigned is_prefetch);
+void starpu_release_data_on_node(struct starpu_data_state_t *state, uint32_t default_wb_mask, unsigned memory_node);
 
-void update_data_state(struct starpu_data_state_t *state, uint32_t requesting_node, uint8_t write);
+void starpu_update_data_state(struct starpu_data_state_t *state, uint32_t requesting_node, uint8_t write);
 
-uint32_t get_data_refcnt(struct starpu_data_state_t *state, uint32_t node);
+uint32_t starpu_get_data_refcnt(struct starpu_data_state_t *state, uint32_t node);
 
-void push_task_output(struct starpu_task *task, uint32_t mask);
+void starpu_push_task_output(struct starpu_task *task, uint32_t mask);
 
 __attribute__((warn_unused_result))
 int _starpu_fetch_task_input(struct starpu_task *task, uint32_t mask);
 
-unsigned is_data_present_or_requested(struct starpu_data_state_t *state, uint32_t node);
+unsigned starpu_is_data_present_or_requested(struct starpu_data_state_t *state, uint32_t node);
 
-inline void set_data_requested_flag_if_needed(struct starpu_data_state_t *state, uint32_t node);
+inline void starpu_set_data_requested_flag_if_needed(struct starpu_data_state_t *state, uint32_t node);
 
-int prefetch_task_input_on_node(struct starpu_task *task, uint32_t node);
+int starpu_prefetch_task_input_on_node(struct starpu_task *task, uint32_t node);
 
-uint32_t select_node_to_handle_request(uint32_t src_node, uint32_t dst_node);
-uint32_t select_src_node(struct starpu_data_state_t *state);
+uint32_t starpu_select_node_to_handle_request(uint32_t src_node, uint32_t dst_node);
+uint32_t starpu_select_src_node(struct starpu_data_state_t *state);
 
 #endif // __COHERENCY__H__

src/datawizard/data_request.c

@@ -209,7 +209,7 @@ static void handle_data_request_completion(data_request_t r)
 	uint32_t src_node = r->src_node;
 	uint32_t dst_node = r->dst_node;
 
-	update_data_state(handle, dst_node, r->write);
+	starpu_update_data_state(handle, dst_node, r->write);
 
 #ifdef STARPU_USE_FXT
 	size_t size = handle->ops->get_size(handle);

src/datawizard/datastats.c

@@ -40,7 +40,7 @@ inline void msi_cache_miss(unsigned node __attribute__ ((unused)))
 #endif
 }
 
-void display_msi_stats(void)
+void starpu_display_msi_stats(void)
 {
 #ifdef STARPU_DATA_STATS
 	unsigned node;

src/datawizard/datastats.h

@@ -24,7 +24,7 @@
 inline void msi_cache_hit(unsigned node);
 inline void msi_cache_miss(unsigned node);
 
-void display_msi_stats(void);
+void starpu_display_msi_stats(void);
 
 inline void allocation_cache_hit(unsigned node __attribute__ ((unused)));
 inline void data_allocation_inc_stats(unsigned node __attribute__ ((unused)));

src/datawizard/hierarchy.c

@@ -35,7 +35,7 @@ void starpu_delete_data(starpu_data_handle handle)
 	STARPU_ASSERT(handle);
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		local_data_state *local = &handle->per_node[node];
+		starpu_local_data_state *local = &handle->per_node[node];
 
 		if (local->allocated && local->automatically_allocated){
 			/* free the data copy in a lazy fashion */
@@ -79,14 +79,14 @@ void register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t w
 	{
 		if (node == home_node) {
 			/* this is the home node with the only valid copy */
-			handle->per_node[node].state = OWNER;
+			handle->per_node[node].state = STARPU_OWNER;
 			handle->per_node[node].allocated = 1;
 			handle->per_node[node].automatically_allocated = 0;
 			handle->per_node[node].refcnt = 0;
 		}
 		else {
 			/* the value is not available here yet */
-			handle->per_node[node].state = INVALID;
+			handle->per_node[node].state = STARPU_INVALID;
 			handle->per_node[node].allocated = 0;
 			handle->per_node[node].refcnt = 0;
 		}
@@ -239,7 +239,7 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 			starpu_unpartition_data(&root_handle->children[child], gathering_node);
 
 		int ret;
-		ret = fetch_data_on_node(&root_handle->children[child], gathering_node, 1, 0, 0);
+		ret = starpu_fetch_data_on_node(&root_handle->children[child], gathering_node, 1, 0, 0);
 		/* for now we pretend that the RAM is almost unlimited and that gathering 
 		 * data should be possible from the node that does the unpartionning ... we
 		 * don't want to have the programming deal with memory shortage at that time,
@@ -258,8 +258,8 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 	unsigned still_valid[STARPU_MAXNODES];
 
 	/* we do 2 passes : the first pass determines wether the data is still
-	 * valid or not, the second pass is needed to choose between SHARED and
-	 * OWNER */
+	 * valid or not, the second pass is needed to choose between STARPU_SHARED and
+	 * STARPU_OWNER */
 
 	unsigned nvalids = 0;
 
@@ -271,9 +271,9 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 
 		for (child = 0; child < root_handle->nchildren; child++)
 		{
-			local_data_state *local = &root_handle->children[child].per_node[node];
+			starpu_local_data_state *local = &root_handle->children[child].per_node[node];
 
-			if (local->state == INVALID) {
+			if (local->state == STARPU_INVALID) {
 				isvalid = 0; 
 			}
 	
@@ -292,12 +292,12 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 	/* either shared or owned */
 	STARPU_ASSERT(nvalids > 0);
 
-	cache_state newstate = (nvalids == 1)?OWNER:SHARED;
+	starpu_cache_state newstate = (nvalids == 1)?STARPU_OWNER:STARPU_SHARED;
 
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
 		root_handle->per_node[node].state = 
-			still_valid[node]?newstate:INVALID;
+			still_valid[node]?newstate:STARPU_INVALID;
 	}
 
 	/* there is no child anymore */

src/datawizard/memalloc.c

@@ -85,7 +85,7 @@ static void unlock_all_subtree(starpu_data_handle handle)
 static unsigned may_free_subtree(starpu_data_handle handle, unsigned node)
 {
 	/* we only free if no one refers to the leaf */
-	uint32_t refcnt = get_data_refcnt(handle, node);
+	uint32_t refcnt = starpu_get_data_refcnt(handle, node);
 	if (refcnt)
 		return 0;
 	
@@ -133,11 +133,11 @@ static void transfer_subtree_to_node(starpu_data_handle handle, unsigned src_nod
 	{
 		/* this is a leaf */
 		switch(handle->per_node[src_node].state) {
-		case OWNER:
+		case STARPU_OWNER:
 			/* the local node has the only copy */
 			/* the owner is now the destination_node */
-			handle->per_node[src_node].state = INVALID;
-			handle->per_node[dst_node].state = OWNER;
+			handle->per_node[src_node].state = STARPU_INVALID;
+			handle->per_node[dst_node].state = STARPU_OWNER;
 
 #warning we should use requests during memory reclaim
 			/* TODO use request !! */
@@ -151,25 +151,25 @@ static void transfer_subtree_to_node(starpu_data_handle handle, unsigned src_nod
 			handle->per_node[dst_node].refcnt--;
 
 			break;
-		case SHARED:
+		case STARPU_SHARED:
 			/* some other node may have the copy */
-			handle->per_node[src_node].state = INVALID;
+			handle->per_node[src_node].state = STARPU_INVALID;
 
 			/* count the number of copies */
 			cnt = 0;
 			for (i = 0; i < STARPU_MAXNODES; i++)
 			{
-				if (handle->per_node[i].state == SHARED) {
+				if (handle->per_node[i].state == STARPU_SHARED) {
 					cnt++; 
 					last = i;
 				}
 			}
 
 			if (cnt == 1)
-				handle->per_node[last].state = OWNER;
+				handle->per_node[last].state = STARPU_OWNER;
 
 			break;
-		case INVALID:
+		case STARPU_INVALID:
 			/* nothing to be done */
 			break;
 		default:

src/datawizard/user_interactions.c

@@ -62,7 +62,7 @@ static inline void _starpu_sync_data_with_mem_continuation(void *arg)
 	unsigned r = (statenode->mode != STARPU_W);
 	unsigned w = (statenode->mode != STARPU_R);
 
-	ret = fetch_data_on_node(handle, 0, r, w, 0);
+	ret = starpu_fetch_data_on_node(handle, 0, r, w, 0);
 	STARPU_ASSERT(!ret);
 	
 	if (statenode->non_blocking)
@@ -160,7 +160,7 @@ void starpu_release_data_from_mem(starpu_data_handle handle)
 	STARPU_ASSERT(handle);
 
 	/* The application can now release the rw-lock */
-	release_data_on_node(handle, 0, 0);
+	starpu_release_data_on_node(handle, 0, 0);
 }
 
 
@@ -169,7 +169,7 @@ static void _prefetch_data_on_node(void *arg)
 {
 	struct state_and_node *statenode = arg;
 
-	fetch_data_on_node(statenode->state, statenode->node, 1, 0, statenode->async);
+	starpu_fetch_data_on_node(statenode->state, statenode->node, 1, 0, statenode->async);
 
 	pthread_mutex_lock(&statenode->lock);
 	statenode->finished = 1;
@@ -208,7 +208,7 @@ int _starpu_prefetch_data_on_node_with_mode(starpu_data_handle handle, unsigned
 		/* we can immediately proceed */
 		uint8_t read = (mode != STARPU_W);
 		uint8_t write = (mode != STARPU_R);
-		fetch_data_on_node(handle, node, read, write, async);
+		starpu_fetch_data_on_node(handle, node, read, write, async);
 
 		/* remove the "lock"/reference */
 		if (!async)

src/datawizard/write_back.c

@@ -37,7 +37,7 @@ void write_through_data(starpu_data_handle handle, uint32_t requesting_node,
 			if (node != requesting_node) 
 			{
 				uint32_t handling_node =
-					select_node_to_handle_request(requesting_node, node);
+					starpu_select_node_to_handle_request(requesting_node, node);
 
 				data_request_t r;
 

src/drivers/cpu/driver_cpu.c

@@ -67,7 +67,7 @@ static int execute_job_on_cpu(job_t j, struct worker_s *cpu_args)
 	TRACE_END_CODELET_BODY(j);
 	cpu_args->status = STATUS_UNKNOWN;
 
-	push_task_output(task, 0);
+	starpu_push_task_output(task, 0);
 
 //#ifdef STARPU_MODEL_DEBUG
 	if (calibrate_model || BENCHMARK_COMM)

src/drivers/cuda/driver_cuda.c

@@ -158,7 +158,7 @@ static int execute_job_on_cuda(job_t j, struct worker_s *args)
 
 	args->jobq->total_job_performed++;
 
-	push_task_output(task, mask);
+	starpu_push_task_output(task, mask);
 
 	return 0;
 }

src/drivers/gordon/driver_gordon.c

@@ -170,7 +170,7 @@ static struct gordon_task_wrapper_s *starpu_to_gordon_job(job_t j)
 
 static void handle_terminated_job(job_t j)
 {
-	push_task_output(j->task, 0);
+	starpu_push_task_output(j->task, 0);
 	_starpu_handle_job_termination(j);
 	starpu_wake_all_blocked_workers();
 }
@@ -208,7 +208,7 @@ static void gordon_callback_list_func(void *arg)
 			_starpu_update_perfmodel_history(j, STARPU_GORDON_DEFAULT, cpuid, measured);
 		}
 
-		push_task_output(j->task, 0);
+		starpu_push_task_output(j->task, 0);
 		_starpu_handle_job_termination(j);
 		//starpu_wake_all_blocked_workers();
 

tools/perfmodel-display.c

@@ -101,7 +101,7 @@ static void display_perf_model(struct starpu_perfmodel_t *model, enum starpu_per
 		/* no specific parameter was requested, so we display everything */
 		fprintf(stderr, "\tRegression : #sample = %d (%s)\n",
 			arch_model->regression.nsample,
-			arch_model->regression.valid?"VALID":"INVALID");
+			arch_model->regression.valid?"VALID":"STARPU_INVALID");
 	
 		/* Only display the regression model if we could actually build a model */
 		if (arch_model->regression.valid)