To avoid problems when linking dynamically, we prefix some internal functions

with "_starpu".

examples/pastix-wrappers/starpu-blas-wrapper.c

@@ -233,7 +233,7 @@ void STARPU_DECLARE_WORK_BLOCKS(float *maxbloktab1, float *maxbloktab2, unsigned
 	cl.where = CUDA;
 	cl.cuda_func = allocate_maxbloktab_on_cublas;
 	
-	j = job_create();
+	j = _starpu_job_create();
 	j->cb = _cublas_cblk_strsm_callback;
 	j->argcb = &sem;
 	j->cl = &cl;
@@ -322,7 +322,7 @@ void STARPU_CBLK_STRSM(unsigned col)
 	cl.core_func = _core_cblk_strsm;
 	cl.cuda_func = _cublas_cblk_strsm;
 	
-	j = job_create();
+	j = _starpu_job_create();
 //	j->where = (starpu_get_blas_nx(&cblktab[col]) > BLOCK && starpu_get_blas_ny(&cblktab[col]) > BLOCK)? CUBLAS:CORE;
 	j->cb = _cublas_cblk_strsm_callback;
 	j->argcb = &sem;
@@ -462,7 +462,7 @@ void STARPU_COMPUTE_CONTRIB_COMPACT(unsigned col, int dimi, int dimj, int dima,
 	cl.core_func = _core_compute_contrib_compact;
 	cl.cuda_func = _cublas_compute_contrib_compact;
 	
-	j = job_create();
+	j = _starpu_job_create();
 
 	j->cb = _cublas_cblk_strsm_callback;
 	j->argcb = &sem;
@@ -604,7 +604,7 @@ void STARPU_SGEMM (const char *transa, const char *transb, const int m,
 	//cl.core_func = _core_strsm;
 	cl.cuda_func = _cublas_sgemm;
 	
-	j = job_create();
+	j = _starpu_job_create();
 	j->cb = _cublas_sgemm_callback;
 	j->argcb = &sem;
 	j->cl = &cl;

src/core/jobs.c

@@ -20,8 +20,7 @@
 #include <core/dependencies/data-concurrency.h>
 #include <common/config.h>
 
-
-size_t job_get_data_size(job_t j)
+size_t _starpu_job_get_data_size(job_t j)
 {
 	size_t size = 0;
 
@@ -40,7 +39,7 @@ size_t job_get_data_size(job_t j)
 }
 
 /* create an internal job_t structure to encapsulate the task */
-job_t __attribute__((malloc)) job_create(struct starpu_task *task)
+job_t __attribute__((malloc)) _starpu_job_create(struct starpu_task *task)
 {
 	job_t job;
 
@@ -74,7 +73,7 @@ void starpu_wait_job(job_t j)
 	job_delete(j);
 }
 
-void handle_job_termination(job_t j)
+void _starpu_handle_job_termination(job_t j)
 {
 	struct starpu_task *task = j->task;
 
@@ -118,12 +117,12 @@ void handle_job_termination(job_t j)
 			free(task);
 	}
 
-	decrement_nsubmitted_tasks();
+	_starpu_decrement_nsubmitted_tasks();
 }
 
 /* This function is called when a new task is submitted to StarPU 
  * it returns 1 if the task deps are not fulfilled, 0 otherwise */
-static unsigned not_all_task_deps_are_fulfilled(job_t j)
+static unsigned _starpu_not_all_task_deps_are_fulfilled(job_t j)
 {
 	unsigned ret;
 
@@ -154,12 +153,12 @@ static unsigned not_all_task_deps_are_fulfilled(job_t j)
 	return ret;
 }
 
-unsigned enforce_deps_and_schedule(job_t j)
+unsigned _starpu_enforce_deps_and_schedule(job_t j)
 {
 	unsigned ret;
 
 	/* enfore task dependencies */
-	if (not_all_task_deps_are_fulfilled(j))
+	if (_starpu_not_all_task_deps_are_fulfilled(j))
 		return 0;
 
 	/* enforce data dependencies */
@@ -171,7 +170,7 @@ unsigned enforce_deps_and_schedule(job_t j)
 	return ret;
 }
 
-struct job_s *pop_local_task(struct worker_s *worker)
+struct job_s *_starpu_pop_local_task(struct worker_s *worker)
 {
 	struct job_s *j = NULL;
 
@@ -185,7 +184,7 @@ struct job_s *pop_local_task(struct worker_s *worker)
 	return j;
 }
 
-int push_local_task(struct worker_s *worker, struct job_s *j)
+int _starpu_push_local_task(struct worker_s *worker, struct job_s *j)
 {
 	/* TODO check that the worker is able to execute the task ! */
 

src/core/jobs.h

@@ -68,18 +68,18 @@ LIST_TYPE(job,
 	unsigned terminated;
 );
 
-job_t __attribute__((malloc)) job_create(struct starpu_task *task);
+job_t __attribute__((malloc)) _starpu_job_create(struct starpu_task *task);
 void starpu_wait_job(job_t j);
 
 /* try to submit job j, enqueue it if it's not schedulable yet */
-unsigned enforce_deps_and_schedule(job_t j);
+unsigned _starpu_enforce_deps_and_schedule(job_t j);
 
 //#warning this must not be exported anymore ... 
-//job_t job_create(struct starpu_task *task);
-void handle_job_termination(job_t j);
-size_t job_get_data_size(job_t j);
+//job_t _starpu_job_create(struct starpu_task *task);
+void _starpu_handle_job_termination(job_t j);
+size_t _starpu_job_get_data_size(job_t j);
 
-job_t pop_local_task(struct worker_s *worker);
-int push_local_task(struct worker_s *worker, job_t j);
+job_t _starpu_pop_local_task(struct worker_s *worker);
+int _starpu_push_local_task(struct worker_s *worker, job_t j);
 
 #endif // __JOBS_H__

src/core/perfmodel/perfmodel_history.c

@@ -498,7 +498,7 @@ void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *model,
 double regression_based_job_expected_length(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct job_s *j)
 {
 	double exp = -1.0;
-	size_t size = job_get_data_size(j);
+	size_t size = _starpu_job_get_data_size(j);
 	struct starpu_regression_model_t *regmodel;
 
 	if (STARPU_UNLIKELY(model->is_loaded != STARPU_PERFMODEL_LOADED))
@@ -582,7 +582,7 @@ void update_perfmodel_history(job_t j, enum starpu_perf_archtype arch, unsigned
 						entry->deviation = 0.0;
 						entry->sum2 = measured*measured;
 	
-						entry->size = job_get_data_size(j);
+						entry->size = _starpu_job_get_data_size(j);
 	
 						entry->footprint = key;
 						entry->nsample = 1;
@@ -632,7 +632,7 @@ void update_perfmodel_history(job_t j, enum starpu_perf_archtype arch, unsigned
 
 		STARPU_ASSERT(j->footprint_is_computed);
 
-		fprintf(debug_file, "0x%x\t%lu\t%lf\t%lf\t%d\t\t", j->footprint, (unsigned long) job_get_data_size(j), measured, j->predicted, cpuid);
+		fprintf(debug_file, "0x%x\t%lu\t%lf\t%lf\t%d\t\t", j->footprint, (unsigned long) _starpu_job_get_data_size(j), measured, j->predicted, cpuid);
 		unsigned i;
 			
 		struct starpu_task *task = j->task;

src/core/policies/sched_policy.c

@@ -186,14 +186,14 @@ int push_task(job_t j)
 	 * corresponding dependencies */
 	if (j->task->cl == NULL)
 	{
-		handle_job_termination(j);
+		_starpu_handle_job_termination(j);
 		return 0;
 	}
 
 	if (STARPU_UNLIKELY(j->task->execute_on_a_specific_worker))
 	{
 		struct worker_s *worker = get_worker_struct(j->task->workerid);
-		return push_local_task(worker, j);
+		return _starpu_push_local_task(worker, j);
 	}
 	else {
 		STARPU_ASSERT(queue->push_task);

src/core/task.c

@@ -141,13 +141,13 @@ int starpu_submit_task(struct starpu_task *task)
 
 	/* internally, StarPU manipulates a job_t which is a wrapper around a
  	* task structure */
-	job_t j = job_create(task);
+	job_t j = _starpu_job_create(task);
 
 	task->starpu_private = j;
 
-	increment_nsubmitted_tasks();
+	_starpu_increment_nsubmitted_tasks();
 
-	ret = enforce_deps_and_schedule(j);
+	ret = _starpu_enforce_deps_and_schedule(j);
 
 	/* XXX modify when we'll have starpu_wait_task */
 	if (is_sync)
@@ -211,7 +211,7 @@ int starpu_wait_all_tasks(void)
 	return 0;
 }
 
-void decrement_nsubmitted_tasks(void)
+void _starpu_decrement_nsubmitted_tasks(void)
 {
 	pthread_mutex_lock(&submitted_mutex);
 	if (--nsubmitted == 0)
@@ -225,7 +225,7 @@ void decrement_nsubmitted_tasks(void)
 
 }
 
-void increment_nsubmitted_tasks(void)
+void _starpu_increment_nsubmitted_tasks(void)
 {
 	pthread_mutex_lock(&submitted_mutex);
 	nsubmitted++;

src/core/task.h

@@ -22,7 +22,7 @@
 
 /* In order to implement starpu_wait_all_tasks, we keep track of the number of
  * task currently submitted */
-void increment_nsubmitted_tasks(void);
-void decrement_nsubmitted_tasks(void);
+void _starpu_increment_nsubmitted_tasks(void);
+void _starpu_decrement_nsubmitted_tasks(void);
 
 #endif // __CORE_TASK_H__

src/datawizard/copy-driver.c

@@ -201,7 +201,7 @@ int __attribute__((warn_unused_result)) driver_copy_data_1_to_1(starpu_data_hand
 	unsigned __attribute__((unused)) com_id = 0;
 
 	/* first make sure the destination has an allocated buffer */
-	ret_alloc = allocate_memory_on_node(handle, dst_node, may_alloc);
+	ret_alloc = _starpu_allocate_memory_on_node(handle, dst_node, may_alloc);
 	if (ret_alloc)
 		goto nomem;
 

src/datawizard/hierarchy.c

@@ -39,7 +39,7 @@ void starpu_delete_data(starpu_data_handle handle)
 
 		if (local->allocated && local->automatically_allocated){
 			/* free the data copy in a lazy fashion */
-			request_mem_chunk_removal(handle, node);
+			_starpu_request_mem_chunk_removal(handle, node);
 		}
 	}
 
@@ -279,7 +279,7 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 	
 			if (local->allocated && local->automatically_allocated){
 				/* free the data copy in a lazy fashion */
-				request_mem_chunk_removal(root_handle, node);
+				_starpu_request_mem_chunk_removal(root_handle, node);
 				isvalid = 0; 
 			}
 		}

src/datawizard/memalloc.c

@@ -23,7 +23,7 @@ static mem_chunk_list_t mc_list_to_free[MAXNODES];
 
 static size_t liberate_memory_on_node(mem_chunk_t mc, uint32_t node);
 
-void init_mem_chunk_lists(void)
+void _starpu_init_mem_chunk_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < MAXNODES; i++)
@@ -34,7 +34,7 @@ void init_mem_chunk_lists(void)
 	}
 }
 
-void deinit_mem_chunk_lists(void)
+void _starpu_deinit_mem_chunk_lists(void)
 {
 	unsigned i;
 	for (i = 0; i < MAXNODES; i++)
@@ -448,7 +448,7 @@ static void register_mem_chunk(starpu_data_handle handle, uint32_t dst_node, siz
 	STARPU_ASSERT(!res);
 }
 
-void request_mem_chunk_removal(starpu_data_handle handle, unsigned node)
+void _starpu_request_mem_chunk_removal(starpu_data_handle handle, unsigned node)
 {
 	int res;
 	res = pthread_rwlock_wrlock(&mc_rwlock[node]);
@@ -534,7 +534,7 @@ static size_t liberate_memory_on_node(mem_chunk_t mc, uint32_t node)
  *	not referenced (or part of those).
  *
  */
-int allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node, unsigned may_alloc)
+int _starpu_allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node, unsigned may_alloc)
 {
 	unsigned attempts = 0;
 	size_t allocated_memory;

src/datawizard/memalloc.h

@@ -44,9 +44,9 @@ LIST_TYPE(mem_chunk,
 	unsigned data_was_deleted;
 )
 
-void init_mem_chunk_lists(void);
-void deinit_mem_chunk_lists(void);
-void request_mem_chunk_removal(starpu_data_handle handle, unsigned node);
-int allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node, unsigned may_alloc);
+void _starpu_init_mem_chunk_lists(void);
+void _starpu_deinit_mem_chunk_lists(void);
+void _starpu_request_mem_chunk_removal(starpu_data_handle handle, unsigned node);
+int _starpu_allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node, unsigned may_alloc);
 
 #endif

src/datawizard/memory_nodes.c

@@ -37,7 +37,7 @@ void init_memory_nodes(void)
 	for (i = 0; i < MAXNODES; i++) 
 		descr.nodes[i] = UNUSED; 
 
-	init_mem_chunk_lists();
+	_starpu_init_mem_chunk_lists();
 	init_data_request_lists();
 
 	pthread_rwlock_init(&descr.attached_queues_rwlock, NULL);
@@ -47,7 +47,7 @@ void init_memory_nodes(void)
 void deinit_memory_nodes(void)
 {
 	deinit_data_request_lists();
-	deinit_mem_chunk_lists();
+	_starpu_deinit_mem_chunk_lists();
 
 	pthread_key_delete(memory_node_key);
 }

src/drivers/core/driver_core.c

@@ -154,7 +154,7 @@ void *core_worker(void *arg)
 		jobq_lock(queue);
 
 		/* perhaps there is some local task to be executed first */
-		j = pop_local_task(core_arg);
+		j = _starpu_pop_local_task(core_arg);
 
 		/* otherwise ask a task to the scheduler */
 		if (!j)
@@ -190,7 +190,7 @@ void *core_worker(void *arg)
 			}
 		}
 
-		handle_job_termination(j);
+		_starpu_handle_job_termination(j);
         }
 
 	TRACE_WORKER_DEINIT_START

src/drivers/cuda/driver_cuda.c

@@ -221,7 +221,7 @@ void *cuda_worker(void *arg)
 		jobq_lock(queue);
 
 		/* perhaps there is some local task to be executed first */
-		j = pop_local_task(args);
+		j = _starpu_pop_local_task(args);
 
 		/* otherwise ask a task to the scheduler */
 		if (!j)
@@ -261,7 +261,7 @@ void *cuda_worker(void *arg)
 			}
 		}
 
-		handle_job_termination(j);
+		_starpu_handle_job_termination(j);
 	}
 
 	TRACE_WORKER_DEINIT_START

src/drivers/gordon/driver_gordon.c

@@ -171,7 +171,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);
-	handle_job_termination(j);
+	_starpu_handle_job_termination(j);
 	wake_all_blocked_workers();
 }
 
@@ -209,7 +209,7 @@ static void gordon_callback_list_func(void *arg)
 		}
 
 		push_task_output(j->task, 0);
-		handle_job_termination(j);
+		_starpu_handle_job_termination(j);
 		//wake_all_blocked_workers();
 
 		task_cnt++;