Internal functions are named _starpu_XXX

src/core/dependencies/data-concurrency.c

@@ -118,7 +118,7 @@ static unsigned attempt_to_submit_data_request_from_job(starpu_job_t j, unsigned
 	starpu_access_mode mode = j->task->buffers[buffer_index].mode;
 
 	while (starpu_spin_trylock(&handle->header_lock))
-		_starpu_datawizard_progress(starpu_get_local_memory_node(), 0);
+		_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
 
 	if (handle->refcnt == 0)
 	{

src/core/jobs.c

@@ -62,7 +62,7 @@ starpu_job_t __attribute__((malloc)) _starpu_job_create(struct starpu_task *task
 	return job;
 }
 
-void starpu_wait_job(starpu_job_t j)
+void _starpu_wait_job(starpu_job_t j)
 {
 	STARPU_ASSERT(j->task);
 	STARPU_ASSERT(!j->task->detach);

src/core/jobs.h

@@ -70,7 +70,7 @@ LIST_TYPE(starpu_job,
 );
 
 starpu_job_t __attribute__((malloc)) _starpu_job_create(struct starpu_task *task);
-void starpu_wait_job(starpu_job_t j);
+void _starpu_wait_job(starpu_job_t j);
 
 /* try to submit job j, enqueue it if it's not schedulable yet */
 unsigned _starpu_enforce_deps_and_schedule(starpu_job_t j);

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 (!starpu_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 = starpu_select_src_node(handle);
+			uint32_t src_node = _starpu_select_src_node(handle);
 
 			penalty += predict_transfer_time(src_node, memory_node, size);
 		}

src/core/perfmodel/perfmodel_history.c

@@ -510,7 +510,7 @@ double history_based_job_expected_length(struct starpu_perfmodel_t *model, enum
 		load_history_based_model(model, 1);
 
 	if (STARPU_UNLIKELY(!j->footprint_is_computed))
-		starpu_compute_buffers_footprint(j);
+		_starpu_compute_buffers_footprint(j);
 		
 	uint32_t key = j->footprint;
 

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;
 
-		starpu_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)) , starpu_jo
 	update_data_requests(queue_array[best], task);
 	
 	if (use_prefetch)
-		starpu_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)), starpu_job_t
 	j->predicted = model_best;
 
 	if (use_prefetch)
-		starpu_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(starpu_job_t j)
 		if (use_prefetch)
 		{
 			uint32_t memory_node = starpu_get_worker_memory_node(workerid); 
-			starpu_prefetch_task_input_on_node(task, memory_node);
+			_starpu_prefetch_task_input_on_node(task, memory_node);
 		}
 
 		return _starpu_push_local_task(worker, j);
@@ -256,7 +256,7 @@ void wait_on_sched_event(void)
 
 	pthread_mutex_lock(&q->activity_mutex);
 
-	starpu_handle_all_pending_node_data_requests(starpu_get_local_memory_node());
+	_starpu_handle_all_pending_node_data_requests(_starpu_get_local_memory_node());
 
 	if (_starpu_machine_is_running())
 	{

src/core/task.c

@@ -98,7 +98,7 @@ int starpu_wait_task(struct starpu_task *task)
 
 	starpu_job_t j = (struct starpu_job_s *)task->starpu_private;
 
-	starpu_wait_job(j);
+	_starpu_wait_job(j);
 
 	/* as this is a synchronous task, the liberation of the job
 	   structure was deferred */
@@ -179,7 +179,7 @@ int starpu_submit_task(struct starpu_task *task)
 
 	/* XXX modify when we'll have starpu_wait_task */
 	if (is_sync)
-		starpu_wait_job(j);
+		_starpu_wait_job(j);
 
 	return ret;
 }

src/core/topology.c

@@ -193,7 +193,7 @@ static int _starpu_init_machine_config(struct machine_config_s *config,
 
 		if (explicitval < 0) {
 			config->ncudagpus =
-				STARPU_MIN(starpu_get_cuda_device_count(), STARPU_MAXCUDADEVS);
+				STARPU_MIN(_starpu_get_cuda_device_count(), STARPU_MAXCUDADEVS);
 		} else {
 			/* use the specified value */
 			config->ncudagpus = (unsigned)explicitval;
@@ -534,7 +534,7 @@ int starpu_build_topology(struct machine_config_s *config)
 		return ret;
 
 	/* for the data management library */
-	starpu_init_memory_nodes();
+	_starpu_init_memory_nodes();
 
 	_starpu_init_workers_binding(config);
 
@@ -544,7 +544,7 @@ int starpu_build_topology(struct machine_config_s *config)
 void starpu_destroy_topology(struct machine_config_s *config __attribute__ ((unused)))
 {
 	/* cleanup StarPU internal data structures */
-	starpu_deinit_memory_nodes();
+	_starpu_deinit_memory_nodes();
 
 #ifdef STARPU_HAVE_HWLOC
 	hwloc_topology_destroy(config->hwtopology);

src/core/workers.c

@@ -89,7 +89,7 @@ static void _starpu_init_worker_queue(struct worker_s *workerarg)
 			STARPU_ABORT();
 	}
 		
-	starpu_memory_node_attach_queue(jobq, workerarg->memory_node);
+	_starpu_memory_node_attach_queue(jobq, workerarg->memory_node);
 }
 
 static void _starpu_init_workers(struct machine_config_s *config)
@@ -155,7 +155,7 @@ static void _starpu_init_workers(struct machine_config_s *config)
 					gordon_worker_set.set_is_initialized = 0;
 
 					pthread_create(&gordon_worker_set.worker_thread, NULL, 
-							starpu_gordon_worker, &gordon_worker_set);
+							_starpu_gordon_worker, &gordon_worker_set);
 
 					pthread_mutex_lock(&gordon_worker_set.mutex);
 					if (!gordon_worker_set.set_is_initialized)
@@ -312,7 +312,7 @@ unsigned _starpu_worker_can_block(unsigned memnode)
 {
 	unsigned can_block = 1;
 
-	if (!starpu_check_that_no_data_request_exists(memnode))
+	if (!_starpu_check_that_no_data_request_exists(memnode))
 		can_block = 0;
 
 	if (!_starpu_machine_is_running())
@@ -335,7 +335,7 @@ static void _starpu_operate_on_all_queues_attached_to_node(unsigned nodeid, queu
 	unsigned q_id;
 	struct jobq_s *q;
 
-	starpu_mem_node_descr * const descr = starpu_get_memory_node_description();
+	starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
 
 	pthread_rwlock_rdlock(&descr->attached_queues_rwlock);
 
@@ -380,7 +380,7 @@ static void _starpu_operate_on_all_queues(queue_op op)
 	unsigned q_id;
 	struct jobq_s *q;
 
-	starpu_mem_node_descr * const descr = starpu_get_memory_node_description();
+	starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
 
 	pthread_rwlock_rdlock(&descr->attached_queues_rwlock);
 
@@ -429,14 +429,14 @@ static void _starpu_kill_all_workers(struct machine_config_s *config)
 
 void starpu_shutdown(void)
 {
-	starpu_display_msi_stats();
-	starpu_display_alloc_cache_stats();
+	_starpu_display_msi_stats();
+	_starpu_display_alloc_cache_stats();
 
 	/* tell all workers to shutdown */
 	_starpu_kill_all_workers(&config);
 
 #ifdef STARPU_DATA_STATS
-	starpu_display_comm_amounts();
+	_starpu_display_comm_amounts();
 #endif
 
 	if (starpu_get_env_number("STARPU_CALIBRATE") != -1)

src/datawizard/coherency.c

@@ -20,13 +20,13 @@
 #include <datawizard/write_back.h>
 #include <core/dependencies/data-concurrency.h>
 
-uint32_t starpu_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 !) */
 
-	unsigned src_is_a_gpu = (starpu_get_node_kind(src_node) == STARPU_CUDA_RAM);
-	unsigned dst_is_a_gpu = (starpu_get_node_kind(dst_node) == STARPU_CUDA_RAM);
+	unsigned src_is_a_gpu = (_starpu_get_node_kind(src_node) == STARPU_CUDA_RAM);
+	unsigned dst_is_a_gpu = (_starpu_get_node_kind(dst_node) == STARPU_CUDA_RAM);
 
 	/* we do not handle GPU->GPU transfers yet ! */
 	STARPU_ASSERT( !(src_is_a_gpu && dst_is_a_gpu) );
@@ -40,15 +40,15 @@ uint32_t starpu_select_node_to_handle_request(uint32_t src_node, uint32_t dst_no
 	/* otherwise perform it locally, since we should be on a "sane" arch
 	 * where anyone can do the transfer. NB: in StarPU this should actually never
 	 * happen */
-	return starpu_get_local_memory_node();
+	return _starpu_get_local_memory_node();
 }
 
-uint32_t starpu_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 = starpu_get_memory_nodes_count();
+	unsigned nnodes = _starpu_get_memory_nodes_count();
 
 	/* first find a valid copy, either a STARPU_OWNER or a STARPU_SHARED */
 	uint32_t node;
@@ -75,7 +75,7 @@ uint32_t starpu_select_src_node(starpu_data_handle handle)
 
 			/* however GPU are expensive sources, really !
 			 * 	other should be ok */
-			if (starpu_get_node_kind(i) != STARPU_CUDA_RAM)
+			if (_starpu_get_node_kind(i) != STARPU_CUDA_RAM)
 				break;
 
 			/* XXX do a better algorithm to distribute the memory copies */
@@ -87,9 +87,9 @@ uint32_t starpu_select_src_node(starpu_data_handle handle)
 }
 
 /* this may be called once the data is fetched with header and STARPU_RW-lock hold */
-void starpu_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 = starpu_get_memory_nodes_count();
+	unsigned nnodes = _starpu_get_memory_nodes_count();
 
 	/* the data is present now */
 	handle->per_node[requesting_node].requested = 0;
@@ -138,10 +138,10 @@ void starpu_update_data_state(starpu_data_handle handle, uint32_t requesting_nod
  * 		    else (invalid,owner->shared)
  */
 
-int starpu_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 = starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_get_local_memory_node();
 
 	while (starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(local_node, 1);
@@ -152,8 +152,8 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 	if (handle->per_node[requesting_node].state != STARPU_INVALID)
 	{
 		/* the data is already available so we can stop */
-		starpu_update_data_state(handle, requesting_node, write);
-		starpu_msi_cache_hit(requesting_node);
+		_starpu_update_data_state(handle, requesting_node, write);
+		_starpu_msi_cache_hit(requesting_node);
 		starpu_spin_unlock(&handle->header_lock);
 		return 0;
 	}
@@ -161,13 +161,13 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 	/* the only remaining situation is that the local copy was invalid */
 	STARPU_ASSERT(handle->per_node[requesting_node].state == STARPU_INVALID);
 
-	starpu_msi_cache_miss(requesting_node);
+	_starpu_msi_cache_miss(requesting_node);
 
 	starpu_data_request_t r;
 
 	/* is there already a pending request ? */
-	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 ! */
+	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":"");
@@ -177,12 +177,12 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 		/* if the data is in read only mode, there is no need for a source */
 		if (read)
 		{
-			src_node = starpu_select_src_node(handle);
+			src_node = _starpu_select_src_node(handle);
 			STARPU_ASSERT(src_node != requesting_node);
 		}
 	
-		unsigned src_is_a_gpu = (starpu_get_node_kind(src_node) == STARPU_CUDA_RAM);
-		unsigned dst_is_a_gpu = (starpu_get_node_kind(requesting_node) == STARPU_CUDA_RAM);
+		unsigned src_is_a_gpu = (_starpu_get_node_kind(src_node) == STARPU_CUDA_RAM);
+		unsigned dst_is_a_gpu = (_starpu_get_node_kind(requesting_node) == STARPU_CUDA_RAM);
 
 		/* we have to perform 2 successive requests for GPU->GPU transfers */
 		if (read && (src_is_a_gpu && dst_is_a_gpu)) {
@@ -191,16 +191,16 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 			starpu_data_request_t r_ram_to_dst;
 
 			/* XXX we hardcore 0 as the STARPU_RAM node ... */
-			r_ram_to_dst = starpu_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 = starpu_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 = starpu_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)
-				starpu_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;
@@ -224,20 +224,20 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 		else {
 			/* who will perform that request ? */
 			uint32_t handling_node =
-				starpu_select_node_to_handle_request(src_node, requesting_node);
+				_starpu_select_node_to_handle_request(src_node, requesting_node);
 
-			r = starpu_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);
 
-			starpu_post_data_request(r, handling_node);
+			_starpu_post_data_request(r, handling_node);
 		}
 	}
 	else {
-		/* the lock was taken by starpu_search_existing_data_request */
+		/* the lock was taken by _starpu_search_existing_data_request */
 
 		/* there is already a similar request */
 		if (is_prefetch)
@@ -266,33 +266,33 @@ int starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_nod
 		starpu_spin_unlock(&handle->header_lock);
 	}
 
-	return (is_prefetch?0:starpu_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)
 {
-	return starpu_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)
 {
-	uint32_t requesting_node = starpu_get_local_memory_node(); 
+	uint32_t requesting_node = _starpu_get_local_memory_node(); 
 
 	uint8_t read, write;
 	read = (mode != STARPU_W); /* then R or STARPU_RW */
 	write = (mode != STARPU_R); /* then STARPU_W or STARPU_RW */
 
-	return starpu_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 starpu_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 starpu_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;
 
@@ -303,10 +303,10 @@ void starpu_release_data_on_node(starpu_data_handle handle, uint32_t default_wb_
 
 	/* are we doing write-through or just some normal write-back ? */
 	if (wb_mask & ~(1<<memory_node)) {
-		starpu_write_through_data(handle, memory_node, wb_mask);
+		_starpu_write_through_data(handle, memory_node, wb_mask);
 	}
 
-	uint32_t local_node = starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_get_local_memory_node();
 	while (starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(local_node, 1);
 
@@ -317,7 +317,7 @@ void starpu_release_data_on_node(starpu_data_handle handle, uint32_t default_wb_
 	starpu_spin_unlock(&handle->header_lock);
 }
 
-int starpu_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;
@@ -350,7 +350,7 @@ int _starpu_fetch_task_input(struct starpu_task *task, uint32_t mask)
 
 //	fprintf(stderr, "_starpu_fetch_task_input\n");
 
-	uint32_t local_memory_node = starpu_get_local_memory_node();
+	uint32_t local_memory_node = _starpu_get_local_memory_node();
 
 	starpu_buffer_descr *descrs = task->buffers;
 	unsigned nbuffers = task->cl->nbuffers;
@@ -383,25 +383,25 @@ enomem:
 	/* XXX broken ... */
 	fprintf(stderr, "something went wrong with buffer %u\n", index);
 	//push_codelet_output(task, index, mask);
-	starpu_push_task_output(task, mask);
+	_starpu_push_task_output(task, mask);
 	return -1;
 }
 
-void starpu_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, "starpu_push_task_output\n");
+	//fprintf(stderr, "_starpu_push_task_output\n");
 
         starpu_buffer_descr *descrs = task->buffers;
         unsigned nbuffers = task->cl->nbuffers;
 
-	uint32_t local_node = starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_get_local_memory_node();
 
 	unsigned index;
 	for (index = 0; index < nbuffers; index++)
 	{
-		starpu_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,7 +409,7 @@ void starpu_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 starpu_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;
 
@@ -425,7 +425,7 @@ unsigned starpu_is_data_present_or_requested(starpu_data_handle handle, uint32_t
 	return ret;
 }
 
-inline void starpu_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);

src/datawizard/coherency.h

@@ -108,28 +108,28 @@ struct starpu_data_state_t {
 	unsigned is_not_important;
 };
 
-void starpu_display_msi_stats(void);
+void _starpu_display_msi_stats(void);
 
 __attribute__((warn_unused_result))
-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);
+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 starpu_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 starpu_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 starpu_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 starpu_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 starpu_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 starpu_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 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);
+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/copy-driver.c

@@ -27,7 +27,7 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 	/* wake up all queues on that node */
 	unsigned q_id;
 
-	starpu_mem_node_descr * const descr = starpu_get_memory_node_description();
+	starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
 
 	pthread_rwlock_rdlock(&descr->attached_queues_rwlock);
 
@@ -59,7 +59,7 @@ void starpu_wake_all_blocked_workers(void)
 
 	/* workers may be blocked on the various queues' conditions */
 	unsigned node;
-	unsigned nnodes = starpu_get_memory_nodes_count();
+	unsigned nnodes = _starpu_get_memory_nodes_count();
 	for (node = 0; node < nnodes; node++)
 	{
 		_starpu_wake_all_blocked_workers_on_node(node);
@@ -81,8 +81,8 @@ static int copy_data_1_to_1_generic(starpu_data_handle handle, uint32_t src_node
 
 	const struct starpu_copy_data_methods_s *copy_methods = handle->ops->copy_methods;
 
-	starpu_node_kind src_kind = starpu_get_node_kind(src_node);
-	starpu_node_kind dst_kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind src_kind = _starpu_get_node_kind(src_node);
+	starpu_node_kind dst_kind = _starpu_get_node_kind(dst_node);
 
 	STARPU_ASSERT(handle->per_node[src_node].refcnt);
 	STARPU_ASSERT(handle->per_node[dst_node].refcnt);
@@ -107,7 +107,7 @@ cudaStream_t *stream;
 			case STARPU_CUDA_RAM:
 				/* CUBLAS_RAM -> STARPU_RAM */
 				/* only the proper CUBLAS thread can initiate this ! */
-				if (starpu_get_local_memory_node() == src_node)
+				if (_starpu_get_local_memory_node() == src_node)
 				{
 					/* only the proper CUBLAS thread can initiate this directly ! */
 					STARPU_ASSERT(copy_methods->cuda_to_ram);
@@ -150,7 +150,7 @@ cudaStream_t *stream;
 			case STARPU_RAM:
 				/* STARPU_RAM -> CUBLAS_RAM */
 				/* only the proper CUBLAS thread can initiate this ! */
-				STARPU_ASSERT(starpu_get_local_memory_node() == dst_node);
+				STARPU_ASSERT(_starpu_get_local_memory_node() == dst_node);
 				STARPU_ASSERT(copy_methods->ram_to_cuda);
 				if (!req || !copy_methods->ram_to_cuda_async)
 				{
@@ -191,7 +191,7 @@ cudaStream_t *stream;
 	return ret;
 }
 
-int __attribute__((warn_unused_result)) starpu_driver_copy_data_1_to_1(starpu_data_handle handle, uint32_t src_node, 
+int __attribute__((warn_unused_result)) _starpu_driver_copy_data_1_to_1(starpu_data_handle handle, uint32_t src_node, 
 		uint32_t dst_node, unsigned donotread, struct starpu_data_request_s *req, unsigned may_alloc)
 {
 	if (!donotread)
@@ -219,7 +219,7 @@ int __attribute__((warn_unused_result)) starpu_driver_copy_data_1_to_1(starpu_da
 
 #ifdef STARPU_DATA_STATS
 		size_t size = handle->ops->get_size(handle);
-		starpu_update_comm_amount(src_node, dst_node, size);
+		_starpu_update_comm_amount(src_node, dst_node, size);
 #endif
 		
 #ifdef STARPU_USE_FXT
@@ -250,10 +250,10 @@ nomem:
 	return ENOMEM;
 }
 
-void starpu_driver_wait_request_completion(starpu_async_channel *async_channel __attribute__ ((unused)),
+void _starpu_driver_wait_request_completion(starpu_async_channel *async_channel __attribute__ ((unused)),
 					unsigned handling_node)
 {
-	starpu_node_kind kind = starpu_get_node_kind(handling_node);
+	starpu_node_kind kind = _starpu_get_node_kind(handling_node);
 #ifdef STARPU_USE_CUDA
 	cudaEvent_t event;
 	cudaError_t cures;
@@ -280,10 +280,10 @@ void starpu_driver_wait_request_completion(starpu_async_channel *async_channel _
 	}
 }
 
-unsigned starpu_driver_test_request_completion(starpu_async_channel *async_channel __attribute__ ((unused)),
+unsigned _starpu_driver_test_request_completion(starpu_async_channel *async_channel __attribute__ ((unused)),
 					unsigned handling_node)
 {
-	starpu_node_kind kind = starpu_get_node_kind(handling_node);
+	starpu_node_kind kind = _starpu_get_node_kind(handling_node);
 	unsigned success;
 #ifdef STARPU_USE_CUDA
 	cudaEvent_t event;

src/datawizard/copy-driver.h

@@ -69,9 +69,9 @@ struct starpu_copy_data_methods_s {
 void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid);
 
 __attribute__((warn_unused_result))
-int starpu_driver_copy_data_1_to_1(starpu_data_handle handle, uint32_t node, 
+int _starpu_driver_copy_data_1_to_1(starpu_data_handle handle, uint32_t node, 
 		uint32_t requesting_node, unsigned donotread, struct starpu_data_request_s *req, unsigned may_allloc);
 
-unsigned starpu_driver_test_request_completion(starpu_async_channel *async_channel, unsigned handling_node);
-void starpu_driver_wait_request_completion(starpu_async_channel *async_channel, unsigned handling_node);
+unsigned _starpu_driver_test_request_completion(starpu_async_channel *async_channel, unsigned handling_node);
+void _starpu_driver_wait_request_completion(starpu_async_channel *async_channel, unsigned handling_node);
 #endif // __COPY_DRIVER_H__

src/datawizard/data_request.c

@@ -28,7 +28,7 @@ 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 starpu_init_data_request_lists(void)
+void _starpu_init_data_request_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
@@ -43,7 +43,7 @@ void starpu_init_data_request_lists(void)
 	}
 }
 
-void starpu_deinit_data_request_lists(void)
+void _starpu_deinit_data_request_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
@@ -67,7 +67,7 @@ static void starpu_data_request_destroy(starpu_data_request_t r)
 }
 
 /* handle->lock should already be taken !  */
-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_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 r = starpu_data_request_new();
 
@@ -109,7 +109,7 @@ starpu_data_request_t starpu_create_data_request(starpu_data_handle handle, uint
 }
 
 /* handle->lock should be taken */
-starpu_data_request_t starpu_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)
 {
 	starpu_data_request_t r = handle->per_node[dst_node].request;
 
@@ -136,12 +136,12 @@ starpu_data_request_t starpu_search_existing_data_request(starpu_data_handle han
 	return r;
 }
 
-int starpu_wait_data_request_completion(starpu_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;
 
-	uint32_t local_node = starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_get_local_memory_node();
 
 	do {
 		starpu_spin_lock(&r->lock);
@@ -178,7 +178,7 @@ int starpu_wait_data_request_completion(starpu_data_request_t r, unsigned may_al
 }
 
 /* this is non blocking */
-void starpu_post_data_request(starpu_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");
@@ -209,7 +209,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	uint32_t src_node = r->src_node;
 	uint32_t dst_node = r->dst_node;
 
-	starpu_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);
@@ -219,7 +219,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	unsigned chained_req;
 	for (chained_req = 0; chained_req < r->next_req_count; chained_req++)
 	{
-		starpu_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;
@@ -262,7 +262,7 @@ static int starpu_handle_data_request(starpu_data_request_t r, unsigned may_allo
 
 	/* perform the transfer */
 	/* the header of the data must be locked by the worker that submitted the request */
-	r->retval = starpu_driver_copy_data_1_to_1(handle, r->src_node, r->dst_node, !r->read, r, may_alloc);
+	r->retval = _starpu_driver_copy_data_1_to_1(handle, r->src_node, r->dst_node, !r->read, r, may_alloc);
 
 	if (r->retval == ENOMEM)
 	{
@@ -291,7 +291,7 @@ static int starpu_handle_data_request(starpu_data_request_t r, unsigned may_allo
 	return 0;
 }
 
-void starpu_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;
 
@@ -345,7 +345,7 @@ void starpu_handle_node_data_requests(uint32_t src_node, unsigned may_alloc)
 static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force)
 {
 	int res;
-//	fprintf(stderr, "starpu_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);
@@ -371,11 +371,11 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 		/* wait until the transfer is terminated */
 		if (force)
 		{
-			starpu_driver_wait_request_completion(&r->async_channel, src_node);
+			_starpu_driver_wait_request_completion(&r->async_channel, src_node);
 			starpu_handle_data_request_completion(r);
 		}
 		else {
-			if (starpu_driver_test_request_completion(&r->async_channel, src_node))
+			if (_starpu_driver_test_request_completion(&r->async_channel, src_node))
 			{
 				
 				starpu_handle_data_request_completion(r);
@@ -395,17 +395,17 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 	starpu_data_request_list_delete(local_list);
 }
 
-void starpu_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 starpu_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 starpu_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 = starpu_data_request_list_empty(data_requests[node]);

src/datawizard/data_request.h

@@ -82,18 +82,18 @@ LIST_TYPE(starpu_data_requester,
 	void *argcb;
 );
 
-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 _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 starpu_handle_pending_node_data_requests(uint32_t src_node);
-void starpu_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 starpu_check_that_no_data_request_exists(uint32_t node);
+int _starpu_check_that_no_data_request_exists(uint32_t node);
 
-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);
+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/datastats.c

@@ -26,21 +26,21 @@ static unsigned hit_cnt[STARPU_MAXNODES];
 static unsigned miss_cnt[STARPU_MAXNODES];
 #endif
 
-inline void starpu_msi_cache_hit(unsigned node __attribute__ ((unused)))
+inline void _starpu_msi_cache_hit(unsigned node __attribute__ ((unused)))
 {
 #ifdef STARPU_DATA_STATS
 	hit_cnt[node]++;
 #endif
 }
 
-inline void starpu_msi_cache_miss(unsigned node __attribute__ ((unused)))
+inline void _starpu_msi_cache_miss(unsigned node __attribute__ ((unused)))
 {
 #ifdef STARPU_DATA_STATS
 	miss_cnt[node]++;
 #endif
 }
 
-void starpu_display_msi_stats(void)
+void _starpu_display_msi_stats(void)
 {
 #ifdef STARPU_DATA_STATS
 	unsigned node;
@@ -76,21 +76,21 @@ static unsigned alloc_cnt[STARPU_MAXNODES];
 static unsigned alloc_cache_hit_cnt[STARPU_MAXNODES];
 #endif
 
-inline void starpu_allocation_cache_hit(unsigned node __attribute__ ((unused)))
+inline void _starpu_allocation_cache_hit(unsigned node __attribute__ ((unused)))
 {
 #ifdef STARPU_DATA_STATS
 	alloc_cache_hit_cnt[node]++;
 #endif
 }
 
-inline void starpu_data_allocation_inc_stats(unsigned node __attribute__ ((unused)))
+inline void _starpu_data_allocation_inc_stats(unsigned node __attribute__ ((unused)))
 {
 #ifdef STARPU_DATA_STATS
 	alloc_cnt[node]++;
 #endif
 }
 
-void starpu_display_alloc_cache_stats(void)
+void _starpu_display_alloc_cache_stats(void)
 {
 #ifdef STARPU_DATA_STATS
 	fprintf(stderr, "Allocation cache stats:\n");
@@ -113,7 +113,7 @@ void starpu_display_alloc_cache_stats(void)
 
 static size_t comm_ammount[STARPU_MAXNODES][STARPU_MAXNODES];
 
-void starpu_display_comm_amounts(void)
+void _starpu_display_comm_amounts(void)
 {
 	unsigned src, dst;
 
@@ -138,14 +138,14 @@ void starpu_display_comm_amounts(void)
 	}
 }
 
-inline void starpu_update_comm_amount(uint32_t src_node, uint32_t dst_node, size_t size)
+inline void _starpu_update_comm_amount(uint32_t src_node, uint32_t dst_node, size_t size)
 {
 	comm_ammount[src_node][dst_node] += size;
 }
 
 #else
 
-inline void starpu_display_comm_amounts(void)
+inline void _starpu_display_comm_amounts(void)
 {
 }
 

src/datawizard/datastats.h

@@ -21,20 +21,20 @@
 #include <stdlib.h>
 
 
-inline void starpu_msi_cache_hit(unsigned node);
-inline void starpu_msi_cache_miss(unsigned node);
+inline void _starpu_msi_cache_hit(unsigned node);
+inline void _starpu_msi_cache_miss(unsigned node);
 
-void starpu_display_msi_stats(void);
+void _starpu_display_msi_stats(void);
 
-inline void starpu_allocation_cache_hit(unsigned node __attribute__ ((unused)));
-inline void starpu_data_allocation_inc_stats(unsigned node __attribute__ ((unused)));
+inline void _starpu_allocation_cache_hit(unsigned node __attribute__ ((unused)));
+inline void _starpu_data_allocation_inc_stats(unsigned node __attribute__ ((unused)));
 
 
-void starpu_display_comm_amounts(void);
-void starpu_display_alloc_cache_stats(void);
+void _starpu_display_comm_amounts(void);
+void _starpu_display_alloc_cache_stats(void);
 
 #ifdef STARPU_DATA_STATS
-inline void starpu_update_comm_amount(uint32_t src_node, uint32_t dst_node, size_t size);
+inline void _starpu_update_comm_amount(uint32_t src_node, uint32_t dst_node, size_t size);
 #endif
 
 #endif

src/datawizard/footprint.c

@@ -17,7 +17,7 @@
 #include <datawizard/footprint.h>
 #include <common/hash.h>
 
-void starpu_compute_buffers_footprint(starpu_job_t j)
+void _starpu_compute_buffers_footprint(starpu_job_t j)
 {
 	uint32_t footprint = 0;
 	unsigned buffer;
@@ -40,7 +40,7 @@ void starpu_compute_buffers_footprint(starpu_job_t j)
 	j->footprint_is_computed = 1;
 }
 
-inline uint32_t starpu_compute_data_footprint(starpu_data_handle handle)
+inline uint32_t _starpu_compute_data_footprint(starpu_data_handle handle)
 {
 	uint32_t interfaceid = (uint32_t)starpu_get_handle_interface_id(handle);
 

src/datawizard/footprint.h

@@ -21,7 +21,7 @@
 
 struct starpu_job_s;
 
-void starpu_compute_buffers_footprint(struct starpu_job_s *j);
-inline uint32_t starpu_compute_data_footprint(starpu_data_handle handle);
+void _starpu_compute_buffers_footprint(struct starpu_job_s *j);
+inline uint32_t _starpu_compute_data_footprint(starpu_data_handle handle);
 
 #endif // __FOOTPRINT_H__

src/datawizard/hierarchy.c

@@ -50,7 +50,7 @@ void starpu_delete_data(starpu_data_handle handle)
 	free(handle);
 }
 
-void starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t wb_mask)
+void _starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t wb_mask)
 {
 	STARPU_ASSERT(handle);
 
@@ -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 = starpu_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 STARPU_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,

src/datawizard/hierarchy.h

@@ -23,6 +23,6 @@
 
 #include <starpu.h>
 
-void starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t wb_mask);
+void _starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, uint32_t wb_mask);
 
 #endif

src/datawizard/interfaces/bcsr_interface.c

@@ -110,7 +110,7 @@ void starpu_register_bcsr_data(starpu_data_handle *handleptr, uint32_t home_node
 		.elemsize = elemsize
 	};
 
-	starpu_register_data_handle(handleptr, home_node, &interface, &interface_bcsr_ops);
+	_starpu_register_data_handle(handleptr, home_node, &interface, &interface_bcsr_ops);
 }
 
 static uint32_t footprint_bcsr_interface_crc32(starpu_data_handle handle)
@@ -176,7 +176,7 @@ size_t starpu_get_bcsr_elemsize(starpu_data_handle handle)
 uintptr_t starpu_get_bcsr_local_nzval(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -241,7 +241,7 @@ static size_t allocate_bcsr_buffer_on_node(starpu_data_handle handle, uint32_t d
 	uint32_t r = interface->r;
 	uint32_t c = interface->c;
 
-	starpu_node_kind kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_RAM:
@@ -327,7 +327,7 @@ static void liberate_bcsr_buffer_on_node(void *interface, uint32_t node)
 {
 	starpu_bcsr_interface_t *bcsr_interface = interface;	
 
-	starpu_node_kind kind = starpu_get_node_kind(node);
+	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_RAM:
 			free((void*)bcsr_interface->nzval);

src/datawizard/interfaces/blas_interface.c

@@ -132,7 +132,7 @@ void starpu_register_blas_data(starpu_data_handle *handleptr, uint32_t home_node
 		.elemsize = elemsize
 	};
 
-	starpu_register_data_handle(handleptr, home_node, &interface, &interface_blas_ops);
+	_starpu_register_data_handle(handleptr, home_node, &interface, &interface_blas_ops);
 }
 
 static uint32_t footprint_blas_interface_crc32(starpu_data_handle handle)
@@ -179,7 +179,7 @@ uint32_t starpu_get_blas_ny(starpu_data_handle handle)
 uint32_t starpu_get_blas_local_ld(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -192,7 +192,7 @@ uint32_t starpu_get_blas_local_ld(starpu_data_handle handle)
 uintptr_t starpu_get_blas_local_ptr(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -232,7 +232,7 @@ static size_t allocate_blas_buffer_on_node(starpu_data_handle handle, uint32_t d
 	uint32_t ld = nx; // by default
 	size_t elemsize = interface->elemsize;
 
-	starpu_node_kind kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_RAM:
@@ -283,7 +283,7 @@ static void liberate_blas_buffer_on_node(void *interface, uint32_t node)
 	cudaError_t status;
 #endif
 
-	starpu_node_kind kind = starpu_get_node_kind(node);
+	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_RAM:
 			free((void*)blas_interface->ptr);

src/datawizard/interfaces/block_interface.c

@@ -125,7 +125,7 @@ void starpu_register_block_data(starpu_data_handle *handleptr, uint32_t home_nod
 		.elemsize = elemsize
 	};
 
-	starpu_register_data_handle(handleptr, home_node, &interface, &interface_block_ops);
+	_starpu_register_data_handle(handleptr, home_node, &interface, &interface_block_ops);
 }
 
 static uint32_t footprint_block_interface_crc32(starpu_data_handle handle)
@@ -188,7 +188,7 @@ uint32_t starpu_get_block_nz(starpu_data_handle handle)
 uint32_t starpu_get_block_local_ldy(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 	
@@ -201,7 +201,7 @@ uint32_t starpu_get_block_local_ldy(starpu_data_handle handle)
 uint32_t starpu_get_block_local_ldz(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -214,7 +214,7 @@ uint32_t starpu_get_block_local_ldz(starpu_data_handle handle)
 uintptr_t starpu_get_block_local_ptr(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -253,7 +253,7 @@ static size_t allocate_block_buffer_on_node(starpu_data_handle handle, uint32_t
 	uint32_t nz = dst_block->nz;
 	size_t elemsize = dst_block->elemsize;
 
-	starpu_node_kind kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_RAM:
@@ -306,7 +306,7 @@ static void liberate_block_buffer_on_node(void *interface, uint32_t node)
 	cudaError_t status;
 #endif
 
-	starpu_node_kind kind = starpu_get_node_kind(node);
+	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_RAM:
 			free((void*)block_interface->ptr);

src/datawizard/interfaces/csr_interface.c

@@ -103,7 +103,7 @@ void starpu_register_csr_data(starpu_data_handle *handleptr, uint32_t home_node,
 		.elemsize = elemsize
 	};
 
-	starpu_register_data_handle(handleptr, home_node, &interface, &interface_csr_ops);
+	_starpu_register_data_handle(handleptr, home_node, &interface, &interface_csr_ops);
 }
 
 static uint32_t footprint_csr_interface_crc32(starpu_data_handle handle)
@@ -147,7 +147,7 @@ size_t starpu_get_csr_elemsize(starpu_data_handle handle)
 uintptr_t starpu_get_csr_local_nzval(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -160,7 +160,7 @@ uintptr_t starpu_get_csr_local_nzval(starpu_data_handle handle)
 uint32_t *starpu_get_csr_local_colind(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -173,7 +173,7 @@ uint32_t *starpu_get_csr_local_colind(starpu_data_handle handle)
 uint32_t *starpu_get_csr_local_rowptr(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -213,7 +213,7 @@ static size_t allocate_csr_buffer_on_node(starpu_data_handle handle, uint32_t ds
 	uint32_t nrow = interface->nrow;
 	size_t elemsize = interface->elemsize;
 
-	starpu_node_kind kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_RAM:
@@ -299,7 +299,7 @@ static void liberate_csr_buffer_on_node(void *interface, uint32_t node)
 {
 	starpu_csr_interface_t *csr_interface = interface;	
 
-	starpu_node_kind kind = starpu_get_node_kind(node);
+	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_RAM:
 			free((void*)csr_interface->nzval);

src/datawizard/interfaces/data_interface.c

@@ -26,7 +26,7 @@ void *starpu_data_get_interface_on_node(starpu_data_handle handle, unsigned memo
 	return handle->interface[memory_node];
 }
 
-void starpu_register_data_handle(starpu_data_handle *handleptr, uint32_t home_node,
+void _starpu_register_data_handle(starpu_data_handle *handleptr, uint32_t home_node,
 				void *interface,
 				struct starpu_data_interface_ops_t *ops)
 {
@@ -39,6 +39,6 @@ void starpu_register_data_handle(starpu_data_handle *handleptr, uint32_t home_no
 	/* fill the interface fields with the appropriate method */
 	ops->register_data_handle(handle, home_node, interface);
 
-	starpu_register_new_data(handle, home_node, 0);
+	_starpu_register_new_data(handle, home_node, 0);
 }
 /* register data interface ? (do we need to register ?) descr =  type enum, required to get an id !  */

src/datawizard/interfaces/data_interface.h

@@ -42,7 +42,7 @@ struct starpu_data_interface_ops_t {
 	size_t interface_size;
 };
 
-void starpu_register_data_handle(starpu_data_handle *handleptr, uint32_t home_node,
+void _starpu_register_data_handle(starpu_data_handle *handleptr, uint32_t home_node,
 				void *interface,
 				struct starpu_data_interface_ops_t *ops);
 

src/datawizard/interfaces/vector_interface.c

@@ -119,7 +119,7 @@ void starpu_register_vector_data(starpu_data_handle *handleptr, uint32_t home_no
 		.elemsize = elemsize
 	};	
 
-	starpu_register_data_handle(handleptr, home_node, &vector, &interface_vector_ops); 
+	_starpu_register_data_handle(handleptr, home_node, &vector, &interface_vector_ops); 
 }
 
 
@@ -159,7 +159,7 @@ uint32_t starpu_get_vector_nx(starpu_data_handle handle)
 uintptr_t starpu_get_vector_local_ptr(starpu_data_handle handle)
 {
 	unsigned node;
-	node = starpu_get_local_memory_node();
+	node = _starpu_get_local_memory_node();
 
 	STARPU_ASSERT(starpu_test_if_data_is_allocated_on_node(handle, node));
 
@@ -192,7 +192,7 @@ static size_t allocate_vector_buffer_on_node(starpu_data_handle handle, uint32_t
 	uint32_t nx = interface->nx;
 	size_t elemsize = interface->elemsize;
 
-	starpu_node_kind kind = starpu_get_node_kind(dst_node);
+	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
@@ -236,7 +236,7 @@ static void liberate_vector_buffer_on_node(void *interface, uint32_t node)
 {
 	starpu_vector_interface_t *vector_interface = interface;
 
-	starpu_node_kind kind = starpu_get_node_kind(node);
+	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_RAM:
 			free((void*)vector_interface->ptr);

src/datawizard/memalloc.c

@@ -50,7 +50,7 @@ static void lock_all_subtree(starpu_data_handle handle)
 	{
 		/* this is a leaf */
 		while (starpu_spin_trylock(&handle->header_lock))
-			_starpu_datawizard_progress(starpu_get_local_memory_node(), 0);
+			_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
 	}
 	else {
 		/* lock all sub-subtrees children */
@@ -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 = starpu_get_data_refcnt(handle, node);
+	uint32_t refcnt = _starpu_get_data_refcnt(handle, node);
 	if (refcnt)
 		return 0;
 	
@@ -144,7 +144,7 @@ static void transfer_subtree_to_node(starpu_data_handle handle, unsigned src_nod
 			handle->per_node[src_node].refcnt++;
 			handle->per_node[dst_node].refcnt++;
 
-			ret = starpu_driver_copy_data_1_to_1(handle, src_node, dst_node, 0, NULL, 1);
+			ret = _starpu_driver_copy_data_1_to_1(handle, src_node, dst_node, 0, NULL, 1);
 			STARPU_ASSERT(ret == 0);
 
 			handle->per_node[src_node].refcnt--;
@@ -426,7 +426,7 @@ static void register_mem_chunk(starpu_data_handle handle, uint32_t dst_node, siz
 
 	mc->data = handle;
 	mc->size = size;
-	mc->footprint = starpu_compute_data_footprint(handle);
+	mc->footprint = _starpu_compute_data_footprint(handle);
 	mc->ops = handle->ops;
 	mc->data_was_deleted = 0;
 	mc->automatically_allocated = automatically_allocated;
@@ -494,7 +494,7 @@ static size_t liberate_memory_on_node(starpu_mem_chunk_t mc, uint32_t node)
 	starpu_data_handle handle = mc->data;
 
 //	while (starpu_spin_trylock(&handle->header_lock))
-//		_starpu_datawizard_progress(starpu_get_local_memory_node());
+//		_starpu_datawizard_progress(_starpu_get_local_memory_node());
 
 #warning can we block here ?
 //	starpu_spin_lock(&handle->header_lock);
@@ -548,16 +548,16 @@ int _starpu_allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node
 	if (!may_alloc)
 		return ENOMEM;
 
-	starpu_data_allocation_inc_stats(dst_node);
+	_starpu_data_allocation_inc_stats(dst_node);
 
 #ifdef STARPU_USE_ALLOCATION_CACHE
 	/* perhaps we can directly reuse a buffer in the free-list */
-	uint32_t footprint = starpu_compute_data_footprint(handle);
+	uint32_t footprint = _starpu_compute_data_footprint(handle);
 
 	TRACE_START_ALLOC_REUSE(dst_node);
 	if (try_to_find_reusable_mem_chunk(dst_node, handle, footprint))
 	{
-		starpu_allocation_cache_hit(dst_node);
+		_starpu_allocation_cache_hit(dst_node);
 		return 0;
 	}
 	TRACE_END_ALLOC_REUSE(dst_node);

src/datawizard/memory_nodes.c

@@ -25,7 +25,7 @@
 static starpu_mem_node_descr descr;
 static pthread_key_t memory_node_key;
 
-void starpu_init_memory_nodes(void)
+void _starpu_init_memory_nodes(void)
 {
 	/* there is no node yet, subsequent nodes will be 
 	 * added using _starpu_register_memory_node */
@@ -38,26 +38,26 @@ void starpu_init_memory_nodes(void)
 		descr.nodes[i] = STARPU_UNUSED; 
 
 	_starpu_init_mem_chunk_lists();
-	starpu_init_data_request_lists();
+	_starpu_init_data_request_lists();
 
 	pthread_rwlock_init(&descr.attached_queues_rwlock, NULL);
 	descr.total_queues_count = 0;
 }
 
-void starpu_deinit_memory_nodes(void)
+void _starpu_deinit_memory_nodes(void)
 {
-	starpu_deinit_data_request_lists();
+	_starpu_deinit_data_request_lists();
 	_starpu_deinit_mem_chunk_lists();
 
 	pthread_key_delete(memory_node_key);
 }
 
-void starpu_set_local_memory_node_key(unsigned *node)
+void _starpu_set_local_memory_node_key(unsigned *node)
 {
 	pthread_setspecific(memory_node_key, node);
 }
 
-unsigned starpu_get_local_memory_node(void)
+unsigned _starpu_get_local_memory_node(void)
 {
 	unsigned *memory_node;
 	memory_node = pthread_getspecific(memory_node_key);
@@ -70,17 +70,17 @@ unsigned starpu_get_local_memory_node(void)
 	return *memory_node;
 }
 
-inline starpu_mem_node_descr *starpu_get_memory_node_description(void)
+inline starpu_mem_node_descr *_starpu_get_memory_node_description(void)
 {
 	return &descr;
 }
 
-inline starpu_node_kind starpu_get_node_kind(uint32_t node)
+inline starpu_node_kind _starpu_get_node_kind(uint32_t node)
 {
 	return descr.nodes[node];
 }
 
-unsigned starpu_get_memory_nodes_count(void)
+unsigned _starpu_get_memory_nodes_count(void)
 {
 	return descr.nnodes;
 }
@@ -102,7 +102,7 @@ unsigned _starpu_register_memory_node(starpu_node_kind kind)
 
 /* TODO move in a more appropriate file  !! */
 /* attach a queue to a memory node (if it's not already attached) */
-void starpu_memory_node_attach_queue(struct jobq_s *q, unsigned nodeid)
+void _starpu_memory_node_attach_queue(struct jobq_s *q, unsigned nodeid)
 {
 	unsigned queue;
 	unsigned nqueues_total, nqueues;

src/datawizard/memory_nodes.h

@@ -46,16 +46,16 @@ typedef struct {
 	unsigned queues_count[STARPU_MAXNODES];
 } starpu_mem_node_descr;
 
-void starpu_init_memory_nodes(void);
-void starpu_deinit_memory_nodes(void);
-void starpu_set_local_memory_node_key(unsigned *node);
-unsigned starpu_get_local_memory_node(void);
+void _starpu_init_memory_nodes(void);
+void _starpu_deinit_memory_nodes(void);
+void _starpu_set_local_memory_node_key(unsigned *node);
+unsigned _starpu_get_local_memory_node(void);
 unsigned _starpu_register_memory_node(starpu_node_kind kind);
-void starpu_memory_node_attach_queue(struct jobq_s *q, unsigned nodeid);
+void _starpu_memory_node_attach_queue(struct jobq_s *q, unsigned nodeid);
 
-starpu_node_kind starpu_get_node_kind(uint32_t node);
-unsigned starpu_get_memory_nodes_count(void);
+starpu_node_kind _starpu_get_node_kind(uint32_t node);
+unsigned _starpu_get_memory_nodes_count(void);
 
-inline starpu_mem_node_descr *starpu_get_memory_node_description(void);
+inline starpu_mem_node_descr *_starpu_get_memory_node_description(void);
 
 #endif // __MEMORY_NODES_H__

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 */
-	starpu_handle_pending_node_data_requests(memory_node);
-	starpu_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

@@ -26,12 +26,12 @@ int starpu_request_data_allocation(starpu_data_handle handle, uint32_t node)
 
 	STARPU_ASSERT(handle);
 
-	r = starpu_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 */
 
-	starpu_post_data_request(r, node);
+	_starpu_post_data_request(r, node);
 
 	return 0;
 }
@@ -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 = starpu_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 */
-	starpu_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;
 
-	starpu_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);
-		starpu_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

@@ -17,7 +17,7 @@
 #include <datawizard/write_back.h>
 #include <datawizard/coherency.h>
 
-void starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_node, 
+void _starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_node, 
 					   uint32_t write_through_mask)
 {
 	if ((write_through_mask & ~(1<<requesting_node)) == 0) {
@@ -37,18 +37,18 @@ void starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_no
 			if (node != requesting_node) 
 			{
 				uint32_t handling_node =
-					starpu_select_node_to_handle_request(requesting_node, node);
+					_starpu_select_node_to_handle_request(requesting_node, node);
 
 				starpu_data_request_t r;
 
 				/* check that there is not already a similar
 				 * request that we should reuse */
-				r = starpu_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 = starpu_create_data_request(handle, requesting_node,
+					r = _starpu_create_data_request(handle, requesting_node,
 							node, handling_node, 1, 0, 1);
-					starpu_post_data_request(r, handling_node);
+					_starpu_post_data_request(r, handling_node);
 				}
 				else {
 					/* if there is already a similar request, it is

src/datawizard/write_back.h

@@ -20,7 +20,7 @@
 #include <starpu.h>
 #include <datawizard/coherency.h>
 
-void starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_node, 
+void _starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_node, 
 					   uint32_t write_through_mask);
 
 #endif // __DW_WRITE_BACK_H__

src/drivers/cpu/driver_cpu.c

@@ -67,7 +67,7 @@ static int execute_job_on_cpu(starpu_job_t j, struct worker_s *cpu_args)
 	TRACE_END_CODELET_BODY(j);
 	cpu_args->status = STATUS_UNKNOWN;
 
-	starpu_push_task_output(task, 0);
+	_starpu_push_task_output(task, 0);
 
 //#ifdef STARPU_MODEL_DEBUG
 	if (calibrate_model || BENCHMARK_COMM)
@@ -109,7 +109,7 @@ void *_starpu_cpu_worker(void *arg)
         fprintf(stderr, "cpu worker %d is ready on logical cpu %d\n", cpu_arg->id, cpu_arg->bindid);
 #endif
 
-	starpu_set_local_memory_node_key(&cpu_arg->memory_node);
+	_starpu_set_local_memory_node_key(&cpu_arg->memory_node);
 
 	set_local_queue(cpu_arg->jobq);
 

src/drivers/cuda/driver_cuda.c

@@ -59,7 +59,7 @@ static void deinit_context(int workerid)
 		STARPU_CUDA_REPORT_ERROR(cures);
 }
 
-unsigned starpu_get_cuda_device_count(void)
+unsigned _starpu_get_cuda_device_count(void)
 {
 	int cnt;
 
@@ -73,7 +73,7 @@ unsigned starpu_get_cuda_device_count(void)
 
 void _starpu_init_cuda(void)
 {
-	ncudagpus = starpu_get_cuda_device_count();
+	ncudagpus = _starpu_get_cuda_device_count();
 	assert(ncudagpus <= STARPU_MAXCUDADEVS);
 }
 
@@ -158,7 +158,7 @@ static int execute_job_on_cuda(starpu_job_t j, struct worker_s *args)
 
 	args->jobq->total_job_performed++;
 
-	starpu_push_task_output(task, mask);
+	_starpu_push_task_output(task, mask);
 
 	return 0;
 }
@@ -177,7 +177,7 @@ void *_starpu_cuda_worker(void *arg)
 
 	_starpu_bind_thread_on_cpu(args->config, args->bindid);
 
-	starpu_set_local_memory_node_key(&(args->memory_node));
+	_starpu_set_local_memory_node_key(&(args->memory_node));
 
 	set_local_queue(args->jobq);
 

src/drivers/cuda/driver_cuda.h

@@ -36,7 +36,7 @@
 
 #include <common/fxt.h>
 
-unsigned starpu_get_cuda_device_count(void);
+unsigned _starpu_get_cuda_device_count(void);
 
 #ifdef STARPU_USE_CUDA
 void _starpu_init_cuda(void);

src/drivers/gordon/driver_gordon.c

@@ -170,7 +170,7 @@ static struct gordon_task_wrapper_s *starpu_to_gordon_job(starpu_job_t j)
 
 static void handle_terminated_job(starpu_job_t j)
 {
-	starpu_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);
 		}
 
-		starpu_push_task_output(j->task, 0);
+		_starpu_push_task_output(j->task, 0);
 		_starpu_handle_job_termination(j);
 		//starpu_wake_all_blocked_workers();
 
@@ -408,7 +408,7 @@ void *gordon_worker_inject(struct worker_set_s *arg)
 	return NULL;
 }
 
-void *starpu_gordon_worker(void *arg)
+void *_starpu_gordon_worker(void *arg)
 {
 	struct worker_set_s *gordon_set_arg = arg;
 

src/drivers/gordon/driver_gordon.h

@@ -39,6 +39,6 @@
 
 #define NMAXGORDONSPUS	8
 
-void *starpu_gordon_worker(void *);
+void *_starpu_gordon_worker(void *);
 
 #endif // __DRIVER_GORDON_H__