merge fixes

src/common/barrier_counter.c

@@ -19,7 +19,7 @@
 int _starpu_barrier_counter_init(struct _starpu_barrier_counter_t *barrier_c, int count)
 {
 	_starpu_barrier_init(&barrier_c->barrier, count);
-	pthread_cond_init(&barrier_c->cond2, NULL);
+	_STARPU_PTHREAD_COND_INIT(&barrier_c->cond2, NULL);
 	return 0;
 }
 
@@ -33,67 +33,67 @@ int _starpu_barrier_counter_update(struct _starpu_barrier_counter_t *barrier_c,
 int _starpu_barrier_counter_destroy(struct _starpu_barrier_counter_t *barrier_c)
 {
 	_starpu_barrier_destroy(&barrier_c->barrier);
-	pthread_cond_destroy(&barrier_c->cond2);
+	_STARPU_PTHREAD_COND_DESTROY(&barrier_c->cond2);
 	return 0;
 }
 
 
 int _starpu_barrier_counter_wait_for_empty_counter(struct _starpu_barrier_counter_t *barrier_c)
 {
-	_starpu_barrier *barrier = &barrier_c->barrier;
-	PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	struct _starpu_barrier *barrier = &barrier_c->barrier;
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	while (barrier->reached_start > 0)
-		PTHREAD_COND_WAIT(&barrier->cond, &barrier->mutex);
+		_STARPU_PTHREAD_COND_WAIT(&barrier->cond, &barrier->mutex);
 
-	PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 
 int _starpu_barrier_counter_wait_for_full_counter(struct _starpu_barrier_counter_t *barrier_c)
 {
-	_starpu_barrier *barrier = &barrier_c->barrier;
-	PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	struct _starpu_barrier *barrier = &barrier_c->barrier;
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	while (barrier->reached_start < barrier->count)
-		PTHREAD_COND_WAIT(&barrier_c->cond2, &barrier->mutex);
+		_STARPU_PTHREAD_COND_WAIT(&barrier_c->cond2, &barrier->mutex);
 
-	PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 
 int _starpu_barrier_counter_decrement_until_empty_counter(struct _starpu_barrier_counter_t *barrier_c)
 {
-	_starpu_barrier *barrier = &barrier_c->barrier;
-	PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	struct _starpu_barrier *barrier = &barrier_c->barrier;
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	if (--barrier->reached_start == 0)
-		PTHREAD_COND_BROADCAST(&barrier->cond);
+		_STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
 
-	PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 
 int _starpu_barrier_counter_increment_until_full_counter(struct _starpu_barrier_counter_t *barrier_c)
 {
-	_starpu_barrier *barrier = &barrier_c->barrier;
-	PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	struct _starpu_barrier *barrier = &barrier_c->barrier;
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 	
 	if(++barrier->reached_start == barrier->count)
-		PTHREAD_COND_BROADCAST(&barrier_c->cond2);
+		_STARPU_PTHREAD_COND_BROADCAST(&barrier_c->cond2);
 
-	PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 
 int _starpu_barrier_counter_increment(struct _starpu_barrier_counter_t *barrier_c)
 {
-	_starpu_barrier *barrier = &barrier_c->barrier;
-	PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	struct _starpu_barrier *barrier = &barrier_c->barrier;
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	barrier->reached_start++;
 	
-	PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 

src/common/barrier_counter.h

@@ -17,11 +17,11 @@
 #include <common/barrier.h>
 
 struct _starpu_barrier_counter_t {
-	_starpu_barrier barrier;
+	struct _starpu_barrier barrier;
 	pthread_cond_t cond2;
 };
 
-int _starpu_barrier_counter_init(struct _starpu_barrier_counter_ *barrier_c, int count);
+int _starpu_barrier_counter_init(struct _starpu_barrier_counter_t *barrier_c, int count);
 
 int _starpu_barrier_counter_update(struct _starpu_barrier_counter_t *barrier_c, int count);
 

src/core/dependencies/implicit_data_deps.c

@@ -302,7 +302,7 @@ void _starpu_detect_implicit_data_deps(struct starpu_task *task)
 		new_task = _starpu_detect_implicit_data_deps_with_handle(task, task, handle, mode);
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 		if (new_task) {
-			int ret = starpu_task_submit_internal(new_task);
+			int ret = _starpu_task_submit_internally(new_task);
 			STARPU_ASSERT(!ret);
 		}
 	}
@@ -455,7 +455,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 			/* There is no need to depend on that task now, since it was already unlocked */
 			_starpu_release_data_enforce_sequential_consistency(link->task, handle);
 
-			int ret = starpu_task_submit_internal(link->task);
+			int ret = _starpu_task_submit_internally(link->task);
 			STARPU_ASSERT(!ret);
 			struct _starpu_task_wrapper_list *tmp = link;
 			link = link->next;
@@ -487,12 +487,12 @@ int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_a
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 		if (new_task) {
-			int ret = starpu_task_submit_internal(new_task);
+			int ret = _starpu_task_submit_internally(new_task);
 			STARPU_ASSERT(!ret);
 		}
 
 		/* TODO detect if this is superflous */
-		int ret = starpu_task_submit_internal(sync_task);
+		int ret = _starpu_task_submit_internally(sync_task);
 		STARPU_ASSERT(!ret);
 		starpu_task_wait(sync_task);
 	}

src/core/jobs.c

@@ -243,7 +243,7 @@ void _starpu_handle_job_termination(struct _starpu_job *j, int workerid)
 		STARPU_ASSERT(detach && !destroy && !task->synchronous);
 
 		/* We reuse the same job structure */
-		int ret = _starpu_submit_job(j, 1);
+		int ret = _starpu_submit_job(j);
 		STARPU_ASSERT(!ret);
 	}
 	_starpu_decrement_nsubmitted_tasks();
@@ -397,15 +397,15 @@ int _starpu_push_local_task(struct _starpu_worker *worker, struct starpu_task *t
 	if (STARPU_UNLIKELY(!(worker->worker_mask & task->cl->where)))
 		return -ENODEV;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
 
 	if (back)
 		starpu_task_list_push_back(&worker->local_tasks, task);
 	else
 		starpu_task_list_push_front(&worker->local_tasks, task);
 
-	_STARPU_PTHREAD_COND_BROADCAST(worker->sched_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(worker->sched_mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&worker->sched_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 
 	return 0;
 }

src/core/sched_ctx.c

@@ -22,15 +22,15 @@ extern struct worker_collection worker_list;
 
 pthread_key_t sched_ctx_key;
 
-static unsigned _starpu_get_first_free_sched_ctx(struct starpu_machine_config_s *config);
-static unsigned _starpu_worker_get_first_free_sched_ctx(struct starpu_worker_s *worker);
+static unsigned _starpu_get_first_free_sched_ctx(struct _starpu_machine_config *config);
+static unsigned _starpu_worker_get_first_free_sched_ctx(struct _starpu_worker *worker);
 
-static unsigned _starpu_worker_get_sched_ctx_id(struct starpu_worker_s *worker, unsigned sched_ctx_id);
+static unsigned _starpu_worker_get_sched_ctx_id(struct _starpu_worker *worker, unsigned sched_ctx_id);
 
 static void change_worker_sched_ctx(unsigned sched_ctx_id)
 {
 	int workerid = starpu_worker_get_id();
-	struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 
 	int worker_sched_ctx_id = _starpu_worker_get_sched_ctx_id(worker, sched_ctx_id);
 	/* if the ctx is not in the worker's list it means the update concerns the addition of ctxs*/
@@ -58,7 +58,7 @@ static void update_workers_func(void *buffers[] __attribute__ ((unused)), void *
 	change_worker_sched_ctx(sched_ctx_id);
 }
 
-struct starpu_codelet_t sched_ctx_info_cl = {
+struct starpu_codelet sched_ctx_info_cl = {
 	.where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL,
 	.cuda_func = update_workers_func,
 	.cpu_func = update_workers_func,
@@ -68,9 +68,9 @@ struct starpu_codelet_t sched_ctx_info_cl = {
 
 static void _starpu_update_workers(int *workerids, int nworkers, int sched_ctx_id)
 {
-	int i, ret;
-	struct starpu_worker_s *worker[nworkers];
- 	struct starpu_worker_s *curr_worker = _starpu_get_local_worker_key();
+	int i;
+	struct _starpu_worker *worker[nworkers];
+ 	struct _starpu_worker *curr_worker = _starpu_get_local_worker_key();
 
 	for(i = 0; i < nworkers; i++)
 	{
@@ -96,7 +96,7 @@ static void _starpu_update_workers(int *workerids, int nworkers, int sched_ctx_i
 
 			_starpu_exclude_task_from_dag(worker[i]->tasks[sched_ctx_id]);
 			
-			ret = _starpu_task_submit_internal(worker[i]->tasks[sched_ctx_id]);
+			_starpu_task_submit_internally(worker[i]->tasks[sched_ctx_id]);
 		}		
 	}
 }
@@ -106,8 +106,7 @@ static void _starpu_add_workers_to_sched_ctx(struct starpu_sched_ctx *sched_ctx,
 				       int *added_workers, int *n_added_workers)
 {
 	struct worker_collection *workers = sched_ctx->workers;
-	struct starpu_machine_config_s *config = (struct starpu_machine_config_s *)_starpu_get_machine_config();
-	int init_nworkers = sched_ctx->workers->nworkers;
+	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 
 	int nworkers_to_add = nworkers == -1 ? config->topology.nworkers : nworkers;
 	int workers_to_add[nworkers_to_add];
@@ -165,7 +164,7 @@ struct starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 				  int nworkers_ctx, unsigned is_initial_sched,
 				  const char *sched_name)
 {
-	struct starpu_machine_config_s *config = (struct starpu_machine_config_s *)_starpu_get_machine_config();
+	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 	STARPU_ASSERT(config->topology.nsched_ctxs < STARPU_NMAX_SCHED_CTXS);
 
 	unsigned id = _starpu_get_first_free_sched_ctx(config);
@@ -176,14 +175,14 @@ struct starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 	
 	STARPU_ASSERT(nworkers_ctx <= nworkers);
   
-	PTHREAD_MUTEX_INIT(&sched_ctx->changing_ctx_mutex, NULL);
- 	PTHREAD_MUTEX_INIT(&sched_ctx->no_workers_mutex, NULL);
-	PTHREAD_COND_INIT(&sched_ctx->no_workers_cond, NULL);
-	PTHREAD_MUTEX_INIT(&sched_ctx->empty_ctx_mutex, NULL);
+	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->changing_ctx_mutex, NULL);
+ 	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->no_workers_mutex, NULL);
+	_STARPU_PTHREAD_COND_INIT(&sched_ctx->no_workers_cond, NULL);
+	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->empty_ctx_mutex, NULL);
 
 	starpu_task_list_init(&sched_ctx->empty_ctx_tasks);
 
-	sched_ctx->sched_policy = (struct starpu_sched_policy_s*)malloc(sizeof(struct starpu_sched_policy_s));
+	sched_ctx->sched_policy = (struct starpu_sched_policy*)malloc(sizeof(struct starpu_sched_policy));
 	sched_ctx->is_initial_sched = is_initial_sched;
 	sched_ctx->name = sched_name;
 
@@ -195,7 +194,7 @@ struct starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 
 	
 	/*init the strategy structs and the worker_collection of the ressources of the context */
-	_starpu_init_sched_policy(config, sched_ctx, policy_name);
+	_starpu_init_sched_policy(config, sched_ctx, sched_name);
 
 	/* construct the collection of workers(list/tree/etc.) */
 	sched_ctx->workers->workerids = sched_ctx->workers->init(sched_ctx->workers);
@@ -213,7 +212,7 @@ struct starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 		int i;
 		for(i = 0; i < nworkers; i++)
 		{
-			struct starpu_worker_s *worker = _starpu_get_worker_struct(i);
+			struct _starpu_worker *worker = _starpu_get_worker_struct(i);
 			worker->sched_ctx[_starpu_worker_get_first_free_sched_ctx(worker)] = sched_ctx;
 			worker->nsched_ctxs++;
 		}
@@ -259,10 +258,10 @@ static void free_sched_ctx_mem(struct starpu_sched_ctx *sched_ctx)
 	sched_ctx->sched_mutex = NULL;
 	sched_ctx->sched_cond = NULL;
 
-	PTHREAD_MUTEX_DESTROY(&sched_ctx->no_workers_mutex);
-	PTHREAD_COND_DESTROY(&sched_ctx->no_workers_cond);
+	_STARPU_PTHREAD_MUTEX_DESTROY(&sched_ctx->no_workers_mutex);
+	_STARPU_PTHREAD_COND_DESTROY(&sched_ctx->no_workers_cond);
 
-	struct starpu_machine_config_s *config = _starpu_get_machine_config();
+	struct _starpu_machine_config *config = _starpu_get_machine_config();
 	config->topology.nsched_ctxs--;
 	sched_ctx->id = STARPU_NMAX_SCHED_CTXS;
 
@@ -273,13 +272,13 @@ void starpu_delete_sched_ctx(unsigned sched_ctx_id, unsigned inheritor_sched_ctx
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	struct starpu_sched_ctx *inheritor_sched_ctx = _starpu_get_sched_ctx_struct(inheritor_sched_ctx_id);
 
-	PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 	_starpu_update_workers(sched_ctx->workers->workerids, sched_ctx->workers->nworkers, sched_ctx->id);
-	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
 
 	/*if both of them have all the ressources is pointless*/
 	/*trying to transfer ressources from one ctx to the other*/
-	struct starpu_machine_config_s *config = (struct starpu_machine_config_s *)_starpu_get_machine_config();
+	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 	int nworkers = config->topology.nworkers;
 
 	if(!(sched_ctx->workers->nworkers == nworkers && sched_ctx->workers->nworkers == inheritor_sched_ctx->workers->nworkers) && sched_ctx->workers->nworkers > 0 && inheritor_sched_ctx_id != STARPU_NMAX_SCHED_CTXS)
@@ -289,9 +288,9 @@ void starpu_delete_sched_ctx(unsigned sched_ctx_id, unsigned inheritor_sched_ctx
 	
 	if(!starpu_wait_for_all_tasks_of_sched_ctx(sched_ctx_id))
 	{
-		PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 		free_sched_ctx_mem(sched_ctx);
-		PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
 	}
 
 	return;	
@@ -316,7 +315,7 @@ void _starpu_delete_all_sched_ctxs()
 
 static void _starpu_check_workers(int *workerids, int nworkers)
 {
-        struct starpu_machine_config_s *config = (struct starpu_machine_config_s *)_starpu_get_machine_config();
+        struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
         int nworkers_conf = config->topology.nworkers;
 
 	int i;
@@ -338,33 +337,33 @@ void starpu_add_workers_to_sched_ctx(int *workers_to_add, int nworkers_to_add, u
 	STARPU_ASSERT(workers_to_add != NULL && nworkers_to_add > 0);
 	_starpu_check_workers(workers_to_add, nworkers_to_add);
 
-	PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 	_starpu_add_workers_to_sched_ctx(sched_ctx, workers_to_add, nworkers_to_add, added_workers, &n_added_workers);
 
 	if(n_added_workers > 0)
 		_starpu_update_workers(added_workers, n_added_workers, sched_ctx->id);
 
-	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
 
 	if(n_added_workers > 0)
 	{
-		PTHREAD_MUTEX_LOCK(&sched_ctx->no_workers_mutex);
-		PTHREAD_COND_BROADCAST(&sched_ctx->no_workers_cond);
-		PTHREAD_MUTEX_UNLOCK(&sched_ctx->no_workers_mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->no_workers_mutex);
+		_STARPU_PTHREAD_COND_BROADCAST(&sched_ctx->no_workers_cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->no_workers_mutex);
 	}
 
 	unsigned unlocked = 0;
-	PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
 	while(!starpu_task_list_empty(&sched_ctx->empty_ctx_tasks))
 	{
 		struct starpu_task *old_task = starpu_task_list_pop_back(&sched_ctx->empty_ctx_tasks);
-		PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 		unlocked = 1;
-		starpu_job_t old_j = _starpu_get_job_associated_to_task(old_task);
-		_starpu_push_task(old_j, 1);
+		struct _starpu_job *old_j = _starpu_get_job_associated_to_task(old_task);
+		_starpu_push_task(old_j);
 	}
 	if(!unlocked)
-		PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 	
 	return;
 }
@@ -378,18 +377,18 @@ void starpu_remove_workers_from_sched_ctx(int *workers_to_remove, int nworkers_t
 	STARPU_ASSERT(workers_to_remove != NULL && nworkers_to_remove > 0);
 	_starpu_check_workers(workers_to_remove, nworkers_to_remove);
 
-	PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 	_starpu_remove_workers_from_sched_ctx(sched_ctx, workers_to_remove, nworkers_to_remove, removed_workers, &n_removed_workers);
 
 	if(n_removed_workers > 0)
 		_starpu_update_workers(removed_workers, n_removed_workers, sched_ctx->id);
 
-	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);	       
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);	       
 	return;
 }
 
 /* unused sched_ctx have the id STARPU_NMAX_SCHED_CTXS */
-void _starpu_init_all_sched_ctxs(struct starpu_machine_config_s *config)
+void _starpu_init_all_sched_ctxs(struct _starpu_machine_config *config)
 {
 	pthread_key_create(&sched_ctx_key, NULL);
 
@@ -403,7 +402,7 @@ void _starpu_init_all_sched_ctxs(struct starpu_machine_config_s *config)
 /* unused sched_ctx pointers of a worker are NULL */
 void _starpu_init_sched_ctx_for_worker(unsigned workerid)
 {
-	struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 	worker->sched_ctx = (struct starpu_sched_ctx**)malloc(STARPU_NMAX_SCHED_CTXS * sizeof(struct starpu_sched_ctx*));
 	unsigned i;
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -415,7 +414,7 @@ void _starpu_init_sched_ctx_for_worker(unsigned workerid)
 /* sched_ctx aren't necessarly one next to another */
 /* for eg when we remove one its place is free */
 /* when we add  new one we reuse its place */
-static unsigned _starpu_get_first_free_sched_ctx(struct starpu_machine_config_s *config)
+static unsigned _starpu_get_first_free_sched_ctx(struct _starpu_machine_config *config)
 {
 	unsigned i;
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -426,7 +425,7 @@ static unsigned _starpu_get_first_free_sched_ctx(struct starpu_machine_config_s
 	return STARPU_NMAX_SCHED_CTXS;
 }
 
-static unsigned _starpu_worker_get_first_free_sched_ctx(struct starpu_worker_s *worker)
+static unsigned _starpu_worker_get_first_free_sched_ctx(struct _starpu_worker *worker)
 {
 	unsigned i;
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -436,7 +435,7 @@ static unsigned _starpu_worker_get_first_free_sched_ctx(struct starpu_worker_s *
 	return STARPU_NMAX_SCHED_CTXS;
 }
 
-static unsigned _starpu_worker_get_sched_ctx_id(struct starpu_worker_s *worker, unsigned sched_ctx_id)
+static unsigned _starpu_worker_get_sched_ctx_id(struct _starpu_worker *worker, unsigned sched_ctx_id)
 {
 	unsigned to_be_deleted = STARPU_NMAX_SCHED_CTXS;
 	unsigned i;
@@ -458,7 +457,7 @@ int starpu_wait_for_all_tasks_of_worker(int workerid)
 	if (STARPU_UNLIKELY(!_starpu_worker_may_perform_blocking_calls()))
 		return -EDEADLK;
 
-	struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 	
 	_starpu_barrier_counter_wait_for_empty_counter(&worker->tasks_barrier);
 	
@@ -468,7 +467,7 @@ int starpu_wait_for_all_tasks_of_worker(int workerid)
 int starpu_wait_for_all_tasks_of_workers(int *workerids, int nworkers_ctx){
 	int ret_val = 0;
 	
-	struct starpu_machine_config_s *config = _starpu_get_machine_config();
+	struct _starpu_machine_config *config = _starpu_get_machine_config();
 	int nworkers = nworkers_ctx == -1 ? (int)config->topology.nworkers : nworkers_ctx;
 	
 	int workerid = -1;
@@ -486,7 +485,7 @@ int starpu_wait_for_all_tasks_of_workers(int *workerids, int nworkers_ctx){
 
 void _starpu_decrement_nsubmitted_tasks_of_worker(int workerid)
 {
-	struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 	
 	_starpu_barrier_counter_decrement_until_empty_counter(&worker->tasks_barrier);
 
@@ -495,7 +494,7 @@ void _starpu_decrement_nsubmitted_tasks_of_worker(int workerid)
 
 void _starpu_increment_nsubmitted_tasks_of_worker(int workerid)
 {
-	struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 
 	_starpu_barrier_counter_increment(&worker->tasks_barrier);
 
@@ -554,7 +553,7 @@ unsigned starpu_get_sched_ctx()
 
 unsigned _starpu_get_nsched_ctxs()
 {
-	struct starpu_machine_config_s *config = (struct starpu_machine_config_s *)_starpu_get_machine_config();
+	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 	return config->topology.nsched_ctxs;
 }
 
@@ -592,15 +591,15 @@ void starpu_worker_init_sched_condition(unsigned sched_ctx_id, int workerid)
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	sched_ctx->sched_mutex[workerid] = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
 	sched_ctx->sched_cond[workerid] = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
-	PTHREAD_MUTEX_INIT(sched_ctx->sched_mutex[workerid], NULL);
-	PTHREAD_COND_INIT(sched_ctx->sched_cond[workerid], NULL);
+	_STARPU_PTHREAD_MUTEX_INIT(sched_ctx->sched_mutex[workerid], NULL);
+	_STARPU_PTHREAD_COND_INIT(sched_ctx->sched_cond[workerid], NULL);
 }
 
 void starpu_worker_deinit_sched_condition(unsigned sched_ctx_id, int workerid)
 {
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	PTHREAD_MUTEX_DESTROY(sched_ctx->sched_mutex[workerid]);
-	PTHREAD_COND_DESTROY(sched_ctx->sched_cond[workerid]);
+	_STARPU_PTHREAD_MUTEX_DESTROY(sched_ctx->sched_mutex[workerid]);
+	_STARPU_PTHREAD_COND_DESTROY(sched_ctx->sched_cond[workerid]);
 	free(sched_ctx->sched_mutex[workerid]);
 	free(sched_ctx->sched_cond[workerid]);
 }
@@ -689,7 +688,7 @@ unsigned starpu_get_nshared_workers(unsigned sched_ctx_id, unsigned sched_ctx_id
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
 void starpu_call_poped_task_cb(int workerid, unsigned sched_ctx_id, double flops)
 {
-	struct starpu_worker_s *worker =  _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker =  _starpu_get_worker_struct(workerid);
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	if(sched_ctx != NULL && sched_ctx_id != 0 && sched_ctx_id != STARPU_NMAX_SCHED_CTXS
 		   && *sched_ctx->perf_counters != NULL)
@@ -698,7 +697,7 @@ void starpu_call_poped_task_cb(int workerid, unsigned sched_ctx_id, double flops
 
 void starpu_call_pushed_task_cb(int workerid, unsigned sched_ctx_id)
 {
-	struct starpu_worker_s *worker =  _starpu_get_worker_struct(workerid);
+	struct _starpu_worker *worker =  _starpu_get_worker_struct(workerid);
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 
 	if(sched_ctx != NULL && sched_ctx_id != 0)

src/core/sched_ctx.h

@@ -35,7 +35,7 @@ struct starpu_sched_ctx {
 	const char *name;
 
 	/* policy of the context */
-	struct starpu_sched_policy_s *sched_policy;
+	struct starpu_sched_policy *sched_policy;
 
 	/* data necessary for the policy */
 	void *policy_data;

src/core/sched_policy.c

@@ -48,7 +48,7 @@ int starpu_get_prefetch_flag(void)
 /* extern struct starpu_sched_policy _starpu_sched_pgreedy_policy; */
 extern struct starpu_sched_policy heft_policy;
 
-static struct starpu_sched_policy_s *predefined_policies[] = {
+static struct starpu_sched_policy *predefined_policies[] = {
 	/* &_starpu_sched_ws_policy, */
 	/* &_starpu_sched_prio_policy, */
 	/* &_starpu_sched_dm_policy, */
@@ -85,7 +85,7 @@ static void load_sched_policy(struct starpu_sched_policy *sched_policy, struct s
 
 	}
 #endif
-        struct starpu_sched_policy_s *policy = sched_ctx->sched_policy;
+        struct starpu_sched_policy *policy = sched_ctx->sched_policy;
 
 	policy->init_sched = sched_policy->init_sched;
 	policy->deinit_sched = sched_policy->deinit_sched;
@@ -143,13 +143,16 @@ static void display_sched_help_message(void)
 	 }
 }
 
-static struct starpu_sched_policy *select_sched_policy(struct _starpu_machine_config *config)
+static struct starpu_sched_policy *select_sched_policy(struct _starpu_machine_config *config, char *required_policy)
 {
 	struct starpu_sched_policy *selected_policy = NULL;
 	struct starpu_conf *user_conf = config->user_conf;
 
+	if(required_policy)
+		selected_policy = find_sched_policy_from_name(required_policy);
+
 	/* First, we check whether the application explicitely gave a scheduling policy or not */
-	if (user_conf && (user_conf->sched_policy))
+	if (!selected_policy && user_conf && (user_conf->sched_policy))
 		return user_conf->sched_policy;
 
 	/* Otherwise, we look if the application specified the name of a policy to load */
@@ -158,7 +161,7 @@ static struct starpu_sched_policy *select_sched_policy(struct _starpu_machine_co
 	if (sched_pol_name == NULL && user_conf && user_conf->sched_policy_name)
 		sched_pol_name = user_conf->sched_policy_name;
 
-	if (sched_pol_name)
+	if (!selected_policy && sched_pol_name)
 		selected_policy = find_sched_policy_from_name(sched_pol_name);
 
 	/* Perhaps there was no policy that matched the name */
@@ -170,7 +173,7 @@ static struct starpu_sched_policy *select_sched_policy(struct _starpu_machine_co
 	return &heft_policy;
 }
 
-void _starpu_init_sched_policy(struct starpu_machine_config *config, struct starpu_sched_ctx *sched_ctx)
+void _starpu_init_sched_policy(struct _starpu_machine_config *config, struct starpu_sched_ctx *sched_ctx, const char *required_policy)
 {
 	/* Perhaps we have to display some help */
 	display_sched_help_message();
@@ -191,7 +194,7 @@ void _starpu_init_sched_policy(struct starpu_machine_config *config, struct star
 	_starpu_set_calibrate_flag(do_calibrate);
 
 	struct starpu_sched_policy *selected_policy;
-	selected_policy = select_sched_policy(config);
+	selected_policy = select_sched_policy(config, required_policy);
 
 	load_sched_policy(selected_policy, sched_ctx);
 
@@ -200,7 +203,7 @@ void _starpu_init_sched_policy(struct starpu_machine_config *config, struct star
 
 void _starpu_deinit_sched_policy(struct starpu_sched_ctx *sched_ctx)
 {
-	struct starpu_sched_policy_s *policy = sched_ctx->sched_policy;
+	struct starpu_sched_policy *policy = sched_ctx->sched_policy;
 	if (policy->deinit_sched)
 		policy->deinit_sched(sched_ctx->id);
 }
@@ -311,7 +314,7 @@ static int _starpu_nworkers_able_to_execute_task(struct starpu_task *task, struc
   while(workers->has_next(workers))
     {
       worker = workers->get_next(workers);
-      if (starpu_worker_may_execute_task(worker, task, 0))
+      if (starpu_worker_can_execute_task(worker, task, 0))
 		  nworkers++;
     }
   
@@ -339,17 +342,17 @@ int _starpu_push_task(struct _starpu_job *j)
 		{
 			if(workerid == -1)
 			{
-				PTHREAD_MUTEX_LOCK(&sched_ctx->no_workers_mutex);
-				PTHREAD_COND_WAIT(&sched_ctx->no_workers_cond, &sched_ctx->no_workers_mutex);
-				PTHREAD_MUTEX_UNLOCK(&sched_ctx->no_workers_mutex);
+				_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->no_workers_mutex);
+				_STARPU_PTHREAD_COND_WAIT(&sched_ctx->no_workers_cond, &sched_ctx->no_workers_mutex);
+				_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->no_workers_mutex);
 				nworkers = _starpu_nworkers_able_to_execute_task(task, sched_ctx);
-				if(nworkers == 0) return _starpu_push_task(j, job_is_already_locked);
+				if(nworkers == 0) return _starpu_push_task(j);
 			}
 			else
 			{
-				PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
+				_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
 				starpu_task_list_push_front(&sched_ctx->empty_ctx_tasks, task);
-				PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+				_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 				return 0;
 			}
 		}
@@ -573,7 +576,6 @@ profiling:
 	}
 
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
-	unsigned i;
 	struct starpu_sched_ctx *sched_ctx = NULL;
 	struct starpu_performance_counters **perf_counters = NULL;
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -630,7 +632,7 @@ void _starpu_wait_on_sched_event(void)
 {
 	struct _starpu_worker *worker = _starpu_get_local_worker_key();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
 
 	_starpu_handle_all_pending_node_data_requests(worker->memory_node);
 
@@ -642,7 +644,7 @@ void _starpu_wait_on_sched_event(void)
 #endif
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 }
 
 /* The scheduling policy may put tasks directly into a worker's local queue so

src/core/sched_policy.h

@@ -26,8 +26,8 @@
 struct starpu_machine_config;
 struct starpu_sched_policy *_starpu_get_sched_policy( struct starpu_sched_ctx *sched_ctx);
 
-void _starpu_init_sched_policy(struct starpu_machine_config *config, 
-			       struct starpu_sched_ctx *sched_ctx);
+void _starpu_init_sched_policy(struct _starpu_machine_config *config, 
+			       struct starpu_sched_ctx *sched_ctx, const char *required_policy);
 
 void _starpu_deinit_sched_policy(struct starpu_sched_ctx *sched_ctx);
 

src/core/task.c

@@ -228,7 +228,7 @@ int _starpu_submit_job(struct _starpu_job *j)
 	j->submitted = 1;
 
 	int ret = _starpu_enforce_deps_and_schedule(j);
-	PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
         _STARPU_LOG_OUT();
         return ret;
@@ -443,7 +443,7 @@ int starpu_task_submit(struct starpu_task *task)
 	return ret;
 }
 
-int _starpu_task_submit_internal(struct starpu_task *task)
+int _starpu_task_submit_internally(struct starpu_task *task)
 {
 	task->control_task = 1;
 	return starpu_task_submit(task);

src/core/task.h

@@ -55,7 +55,7 @@ struct _starpu_job *_starpu_get_job_associated_to_task(struct starpu_task *task)
 struct starpu_task *_starpu_create_task_alias(struct starpu_task *task);
 
 /* Submits starpu internal tasks to the initial context */
-int _starpu_task_submit_internal(struct starpu_task *task);
+int _starpu_task_submit_internally(struct starpu_task *task);
 
 int _starpu_handle_needs_conversion_task(starpu_data_handle_t handle,
 					 unsigned int node);

src/core/topology.c

@@ -700,7 +700,7 @@ void _starpu_bind_thread_on_cpu(struct _starpu_machine_config *config STARPU_ATT
 #endif
 }
 
-static void _starpu_init_workers_binding(struct starpu_machine_config_s *config)
+static void _starpu_init_workers_binding(struct _starpu_machine_config *config)
 {
 	/* launch one thread per CPU */
 	unsigned ram_memory_node;

src/core/workers.c

@@ -784,6 +784,12 @@ struct _starpu_worker *_starpu_get_worker_struct(unsigned id)
 	return &config.workers[id];
 }
 
+struct starpu_sched_ctx *_starpu_get_sched_ctx_struct(unsigned id)
+{
+        STARPU_ASSERT(id >= 0 && id <= STARPU_NMAX_SCHED_CTXS);
+	return &config.sched_ctxs[id];
+}
+
 struct _starpu_combined_worker *_starpu_get_combined_worker_struct(unsigned id)
 {
 	unsigned basic_worker_count = starpu_worker_get_count();

src/sched_policies/heft.c

@@ -72,7 +72,7 @@ static void heft_add_workers(unsigned sched_ctx_id, int *workerids, unsigned nne
 	for (i = 0; i < nnew_workers; i++)
 	{
 		workerid = workerids[i];
-		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(workerid);
+		struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
 		/* init these structures only once for each worker */
 		if(!workerarg->has_prev_init)
 		{
@@ -106,9 +106,9 @@ static void heft_init(unsigned sched_ctx_id)
 	starpu_create_worker_collection_for_sched_ctx(sched_ctx_id, WORKER_LIST);
 
 	heft_data *hd = (heft_data*)malloc(sizeof(heft_data));
-	hd->alpha = STARPU_DEFAULT_ALPHA;
-	hd->beta = STARPU_DEFAULT_BETA;
-	hd->_gamma = STARPU_DEFAULT_GAMMA;
+	hd->alpha = _STARPU_DEFAULT_ALPHA;
+	hd->beta = _STARPU_DEFAULT_BETA;
+	hd->_gamma = _STARPU_DEFAULT_GAMMA;
 	hd->idle_power = 0.0;
 	
 	starpu_set_sched_ctx_policy_data(sched_ctx_id, (void*)hd);
@@ -129,10 +129,10 @@ static void heft_init(unsigned sched_ctx_id)
 	if (strval_idle_power)
 		hd->idle_power = atof(strval_idle_power);
 
-	starputop_register_parameter_float("HEFT_ALPHA", &hd->alpha, alpha_minimum,alpha_maximum,param_modified);
-	starputop_register_parameter_float("HEFT_BETA", &hd->beta, beta_minimum,beta_maximum,param_modified);
-	starputop_register_parameter_float("HEFT_GAMMA", &hd->_gamma, gamma_minimum,gamma_maximum,param_modified);
-	starputop_register_parameter_float("HEFT_IDLE_POWER", &hd->idle_power, idle_power_minimum,idle_power_maximum,param_modified);
+	starpu_top_register_parameter_float("HEFT_ALPHA", &hd->alpha, alpha_minimum,alpha_maximum,param_modified);
+	starpu_top_register_parameter_float("HEFT_BETA", &hd->beta, beta_minimum,beta_maximum,param_modified);
+	starpu_top_register_parameter_float("HEFT_GAMMA", &hd->_gamma, gamma_minimum,gamma_maximum,param_modified);
+	starpu_top_register_parameter_float("HEFT_IDLE_POWER", &hd->idle_power, idle_power_minimum,idle_power_maximum,param_modified);
 }
 
 
@@ -152,7 +152,7 @@ static void heft_pre_exec_hook(struct starpu_task *task)
 	/* the tasks concerning changings of the the ctxs were not executed in order */
 	if(!sched_mutex)
 	{
-		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(workerid);
+		struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
 		sched_mutex = &workerarg->sched_mutex;
 		sched_cond = &workerarg->sched_cond;
 		starpu_worker_set_sched_condition(sched_ctx_id, workerid, sched_mutex, sched_cond);
@@ -170,6 +170,9 @@ static void heft_pre_exec_hook(struct starpu_task *task)
 static void heft_post_exec_hook(struct starpu_task *task)
 {
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
+	unsigned sched_ctx_id = task->sched_ctx;
+	int workerid = starpu_worker_get_id();
+
 	starpu_call_poped_task_cb(workerid, sched_ctx_id, task->flops);
 #endif //STARPU_USE_SCHED_CTX_HYPERVISOR
 }
@@ -191,7 +194,7 @@ static void heft_push_task_notify(struct starpu_task *task, int workerid)
 	/* the tasks concerning changings of the the ctxs were not executed in order */
 	if(!sched_mutex)
 	{
-		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(workerid);
+		struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
 		sched_mutex = &workerarg->sched_mutex;
 		sched_cond = &workerarg->sched_cond;
 		starpu_worker_set_sched_condition(sched_ctx_id, workerid, sched_mutex, sched_cond);
@@ -253,7 +256,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 	/* the tasks concerning changings of the the ctxs were not executed in order */
 	if(!sched_mutex)
 	{
-		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(best_workerid);
+		struct _starpu_worker *workerarg = _starpu_get_worker_struct(best_workerid);
 		sched_mutex = &workerarg->sched_mutex;
 		sched_cond = &workerarg->sched_cond;
 		starpu_worker_set_sched_condition(sched_ctx_id, best_workerid, sched_mutex, sched_cond);
@@ -311,13 +314,14 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 
 /* TODO: factorize with dmda!! */
 static void compute_all_performance_predictions(struct starpu_task *task,
-					double *local_task_length, double *exp_end,
-					double *max_exp_endp, double *best_exp_endp,
-					double *local_data_penalty,
-					double *local_power, 
-					int *forced_worker, int *forced_impl,
-					starpu_task_bundle_t bundle,
-					unsigned sched_ctx_id)
+						double (*local_task_length)[STARPU_MAXIMPLEMENTATIONS], 
+						double (*exp_end)[STARPU_MAXIMPLEMENTATIONS],
+						double *max_exp_endp, double *best_exp_endp,
+						double (*local_data_penalty)[STARPU_MAXIMPLEMENTATIONS],
+						double (*local_power)[STARPU_MAXIMPLEMENTATIONS], 
+						int *forced_worker, int *forced_impl,
+						starpu_task_bundle_t bundle,
+						unsigned sched_ctx_id)
 {
 	int calibrating = 0;
 	double max_exp_end = DBL_MIN;
@@ -356,9 +360,9 @@ static void compute_all_performance_predictions(struct starpu_task *task,
 			if (bundle)
 			{
 				/* TODO : conversion time */
-				local_task_length[worker_ctx][nimpl] = starpu_task_bundle_expected_length(bundle, perf_arch, nimpl);
-				local_data_penalty[worker_ctx][nimpl] = starpu_task_bundle_expected_data_transfer_time(bundle, memory_node);
-				local_power[worker_ctx][nimpl] = starpu_task_bundle_expected_power(bundle, perf_arch, nimpl);
+				local_task_length[worker_ctx][nimpl] = _starpu_task_bundle_expected_length(bundle, perf_arch, nimpl);
+				local_data_penalty[worker_ctx][nimpl] = _starpu_task_bundle_expected_data_transfer_time(bundle, memory_node);
+				local_power[worker_ctx][nimpl] = _starpu_task_bundle_expected_power(bundle, perf_arch, nimpl);
 				//_STARPU_DEBUG("Scheduler heft bundle: task length (%lf) local power (%lf) worker (%u) kernel (%u) \n", local_task_length[worker_ctx],local_power[worker_ctx],worker,nimpl);
 			}
 			else 
@@ -427,6 +431,19 @@ static int push_conversion_tasks(struct starpu_task *task, unsigned int workerid
 	unsigned i;
 	int ret;
 	unsigned int node = starpu_worker_get_memory_node(workerid);
+	unsigned sched_ctx_id = task->sched_ctx;
+	pthread_mutex_t *sched_mutex;
+        pthread_cond_t *sched_cond;
+        starpu_worker_get_sched_condition(sched_ctx_id, workerid, &sched_mutex, &sched_cond);
+        /* the tasks concerning changings of the the ctxs were not executed in order */
+        if(!sched_mutex)
+        {
+                struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
+                sched_mutex = &workerarg->sched_mutex;
+                sched_cond = &workerarg->sched_cond;
+                starpu_worker_set_sched_condition(sched_ctx_id, workerid, sched_mutex, sched_cond);
+        }
+
 
 	_STARPU_PTHREAD_MUTEX_LOCK(&sched_mutex[workerid]);
 	for (i = 0; i < task->cl->nbuffers; i++)
@@ -508,7 +525,7 @@ static int _heft_push_task(struct starpu_task *task, unsigned prio, unsigned sch
 			prio = 0;
 		}
 
-		return push_task_on_best_worker(task, forced_worker, 0.0, 0.0, prio, sched_ctx_id;
+		return push_task_on_best_worker(task, forced_worker, 0.0, 0.0, prio, sched_ctx_id);
 	}
 
 	/*
@@ -537,19 +554,20 @@ static int _heft_push_task(struct starpu_task *task, unsigned prio, unsigned sch
 						+ hd->beta*(local_data_penalty[worker_ctx][nimpl])
 						+ hd->_gamma*(local_power[worker_ctx][nimpl]);
 
-		if (exp_end[worker_ctx][nimpl] > max_exp_end)
-			/* This placement will make the computation
-			 * longer, take into account the idle
-			 * consumption of other cpus */
-			fitness[worker_ctx][nimpl] += hd->_gamma * hd->idle_power * (exp_end[worker_ctx][nimpl] - max_exp_end) / 1000000.0;
-
-		if (best == -1 || fitness[worker_ctx][nimpl] < best_fitness)
-		{
-			/* we found a better solution */
-			best_fitness = fitness[worker_ctx][nimpl];
-			best = worker;
-			best_id_ctx = worker_ctx;
-			selected_impl = nimpl;
+			if (exp_end[worker_ctx][nimpl] > max_exp_end)
+				/* This placement will make the computation
+				 * longer, take into account the idle
+				 * consumption of other cpus */
+				fitness[worker_ctx][nimpl] += hd->_gamma * hd->idle_power * (exp_end[worker_ctx][nimpl] - max_exp_end) / 1000000.0;
+			
+			if (best == -1 || fitness[worker_ctx][nimpl] < best_fitness)
+			{
+				/* we found a better solution */
+				best_fitness = fitness[worker_ctx][nimpl];
+				best = worker;
+				best_id_ctx = worker_ctx;
+				selected_impl = nimpl;
+			}
 		}
 		worker_ctx++;
 	}
@@ -605,29 +623,29 @@ static int heft_push_task(struct starpu_task *task)
 	int ret_val = -1;
 	if (task->priority > 0)
 	{
-		PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
 		nworkers = starpu_get_nworkers_of_sched_ctx(sched_ctx_id);
 		if(nworkers == 0)
 		{
-			PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
+			_STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
 			return ret_val;
 		}
 
 		ret_val = _heft_push_task(task, 1, sched_ctx_id);
-		PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
 		return ret_val;
 	}
 
-	PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
 	nworkers = starpu_get_nworkers_of_sched_ctx(sched_ctx_id);
 	if(nworkers == 0)
 	{
-		PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
 		return ret_val;
 	}
 
 	ret_val = _heft_push_task(task, 0, sched_ctx_id);
-	PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
 	return ret_val;
 }