Reduce a big overhead in starpu_pthread_mutex_lock/unlock by only checking for the sched mutex when locking a sched mutex

include/starpu_config.h.in

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2015  Université de Bordeaux
+ * Copyright (C) 2009-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2015  CNRS
  * Copyright (C) 2014  INRIA
  *
@@ -74,6 +74,7 @@
 
 #undef STARPU_MODEL_DEBUG
 #undef STARPU_NO_ASSERT
+#undef STARPU_DEBUG
 
 #undef STARPU_HAVE_FFTW
 #undef STARPU_HAVE_FFTWF

include/starpu_thread.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010, 2012-2015  Université de Bordeaux
+ * Copyright (C) 2010, 2012-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -109,6 +109,11 @@ int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex);
 
 #endif /* STARPU_SIMGRID, _MSC_VER */
 
+int starpu_pthread_mutex_lock_sched(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_unlock_sched(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_trylock_sched(starpu_pthread_mutex_t *mutex);
+void starpu_pthread_mutex_check_sched(starpu_pthread_mutex_t *mutex, char *file, int line);
+
 /*
  * Encapsulation of the pthread_key_* functions.
  */

include/starpu_thread_util.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010, 2012-2014  Université de Bordeaux
+ * Copyright (C) 2010, 2012-2014, 2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -70,6 +70,13 @@
 	}                                                                      \
 } while(0)
 
+#ifdef STARPU_DEBUG
+#define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line) \
+	starpu_pthread_mutex_check_sched((mutex), file, line)
+#else
+#define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line)
+#endif
+
 #define STARPU_PTHREAD_MUTEX_LOCK(mutex) do {				      \
 	int p_ret = starpu_pthread_mutex_lock(mutex);			      \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
@@ -78,6 +85,17 @@
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
+	_STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__);                                  \
+} while (0)
+
+#define STARPU_PTHREAD_MUTEX_LOCK_SCHED(mutex) do {			      \
+	int p_ret = starpu_pthread_mutex_lock_sched(mutex);		      \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_mutex_lock: %s\n",               \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
 } while (0)
 
 #define STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) \
@@ -92,6 +110,22 @@ int _starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex, char *file, int
 			file, line, strerror(p_ret));
 		STARPU_ABORT();
 	}
+	_STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line);
+	return p_ret;
+}
+
+#define STARPU_PTHREAD_MUTEX_TRYLOCK_SCHED(mutex) \
+	_starpu_pthread_mutex_trylock_sched(mutex, __FILE__, __LINE__)
+static STARPU_INLINE
+int _starpu_pthread_mutex_trylock_sched(starpu_pthread_mutex_t *mutex, char *file, int line)
+{
+	int p_ret = starpu_pthread_mutex_trylock_sched(mutex);
+	if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY)) {
+		fprintf(stderr,
+			"%s:%d starpu_pthread_mutex_trylock: %s\n",
+			file, line, strerror(p_ret));
+		STARPU_ABORT();
+	}
 	return p_ret;
 }
 
@@ -103,6 +137,17 @@ int _starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex, char *file, int
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
+	_STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__);                                  \
+} while (0)
+
+#define STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(mutex) do {                          \
+	int p_ret = starpu_pthread_mutex_unlock_sched(mutex);                  \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_mutex_unlock: %s\n",             \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
 } while (0)
 
 /*

src/common/thread.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010, 2012-2015  Université de Bordeaux
+ * Copyright (C) 2010, 2012-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -545,9 +545,6 @@ int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex)
 	_STARPU_TRACE_LOCKING_MUTEX();
 
 	int p_ret = pthread_mutex_lock(mutex);
-	int workerid = starpu_worker_get_id();
-	if(workerid != -1 && _starpu_worker_mutex_is_sched_mutex(workerid, mutex))
-		_starpu_worker_set_flag_sched_mutex_locked(workerid, 1);
 
 	_STARPU_TRACE_MUTEX_LOCKED();
 
@@ -559,9 +556,6 @@ int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex)
 	_STARPU_TRACE_UNLOCKING_MUTEX();
 
 	int p_ret = pthread_mutex_unlock(mutex);
-	int workerid = starpu_worker_get_id();
-	if(workerid != -1 && _starpu_worker_mutex_is_sched_mutex(workerid, mutex))
-		_starpu_worker_set_flag_sched_mutex_locked(workerid, 0);
 
 	_STARPU_TRACE_MUTEX_UNLOCKED();
 
@@ -656,6 +650,48 @@ int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock)
 }
 #endif
 
+/* "sched" variants, to be used (through the STARPU_PTHREAD_MUTEX_*LOCK_SCHED
+ * macros of course) which record when the mutex is held or not */
+int starpu_pthread_mutex_lock_sched(starpu_pthread_mutex_t *mutex)
+{
+	int p_ret = starpu_pthread_mutex_lock(mutex);
+	int workerid = starpu_worker_get_id();
+	if(workerid != -1 && _starpu_worker_mutex_is_sched_mutex(workerid, mutex))
+		_starpu_worker_set_flag_sched_mutex_locked(workerid, 1);
+	return p_ret;
+}
+
+int starpu_pthread_mutex_unlock_sched(starpu_pthread_mutex_t *mutex)
+{
+	int workerid = starpu_worker_get_id();
+	if(workerid != -1 && _starpu_worker_mutex_is_sched_mutex(workerid, mutex))
+		_starpu_worker_set_flag_sched_mutex_locked(workerid, 0);
+
+	return starpu_pthread_mutex_unlock(mutex);
+}
+
+int starpu_pthread_mutex_trylock_sched(starpu_pthread_mutex_t *mutex)
+{
+	int ret = starpu_pthread_mutex_trylock(mutex);
+
+	if (!ret)
+	{
+		int workerid = starpu_worker_get_id();
+		if(workerid != -1 && _starpu_worker_mutex_is_sched_mutex(workerid, mutex))
+			_starpu_worker_set_flag_sched_mutex_locked(workerid, 1);
+	}
+
+	return ret;
+}
+
+#ifdef STARPU_DEBUG
+void starpu_pthread_mutex_check_sched(starpu_pthread_mutex_t *mutex, char *file, int line)
+{
+	int workerid = starpu_worker_get_id();
+	STARPU_ASSERT_MSG(workerid == -1 || !_starpu_worker_mutex_is_sched_mutex(workerid, mutex), "%s:%d is locking/unlocking a sched mutex but not using STARPU_PTHREAD_MUTEX_LOCK_SCHED", file, line);
+}
+#endif
+
 #if !defined(STARPU_SIMGRID) && !defined(_MSC_VER) && defined(STARPU_HAVE_PTHREAD_BARRIER)
 int starpu_pthread_barrier_wait(starpu_pthread_barrier_t *barrier)
 {

src/core/errorcheck.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009, 2010, 2014  Université de Bordeaux
+ * Copyright (C) 2009, 2010, 2014, 2016  Université de Bordeaux
  * Copyright (C) 2010, 2011  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -23,9 +23,9 @@ void _starpu_set_worker_status(struct _starpu_worker *worker, enum _starpu_worke
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(worker->workerid, &sched_mutex, &sched_cond);
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	worker->status = st;
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 }
 
 void _starpu_set_local_worker_status(enum _starpu_worker_status st)

src/core/jobs.c

@@ -512,14 +512,14 @@ void _starpu_handle_job_termination(struct _starpu_job *j)
 	worker = _starpu_get_local_worker_key();
 	if (worker)
 	{
-		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 
 		if(worker->removed_from_ctx[sched_ctx] == 1 && worker->shares_tasks_lists[sched_ctx] == 1)
 		{
 			_starpu_worker_gets_out_of_ctx(sched_ctx, worker);
 			worker->removed_from_ctx[sched_ctx] = 0;
 		}
-		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 	}
 }
 
@@ -712,7 +712,7 @@ 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_SCHED(&worker->sched_mutex);
 
 	if (task->execute_on_a_specific_worker && task->workerorder)
 	{
@@ -754,7 +754,7 @@ int _starpu_push_local_task(struct _starpu_worker *worker, struct starpu_task *t
 
 	starpu_wake_worker_locked(worker->workerid);
 	starpu_push_task_end(task);
-	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 
 	return 0;
 }

src/core/sched_ctx.c

@@ -88,9 +88,9 @@ static void _starpu_update_workers_with_ctx(int *workerids, int nworkers, int sc
 	{
 		worker = _starpu_get_worker_struct(workerids[i]);
 
-		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 		_starpu_worker_gets_into_ctx(sched_ctx_id, worker);
-		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 	}
 
 	return;
@@ -106,15 +106,15 @@ static void _starpu_update_workers_without_ctx(int *workerids, int nworkers, int
 		worker = _starpu_get_worker_struct(workerids[i]);
 		if(now)
 		{
-			STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 			_starpu_worker_gets_out_of_ctx(sched_ctx_id, worker);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 		}
 		else
 		{
-			STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 			worker->removed_from_ctx[sched_ctx_id] = 1;
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 		}
 	}
 	return;
@@ -134,12 +134,12 @@ void starpu_sched_ctx_worker_shares_tasks_lists(int workerid, int sched_ctx_id)
 	/* if is the initial sched_ctx no point in taking the mutex, the workers are
 	   not launched yet, or if the current worker is calling this */
 	if(!sched_ctx->is_initial_sched && workerid != curr_workerid)
-		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 
 	worker->shares_tasks_lists[sched_ctx_id] = 1;
 
 	if(!sched_ctx->is_initial_sched && workerid != curr_workerid)
-		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 }
 
 static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx, int *workerids, int nworkers,
@@ -174,12 +174,12 @@ static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx
 				int curr_workerid = starpu_worker_get_id();
 				struct _starpu_worker *worker_str = _starpu_get_worker_struct(workerids[i]);
 				if(curr_workerid != workerids[i])
-					STARPU_PTHREAD_MUTEX_LOCK(&worker_str->sched_mutex);
+					STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker_str->sched_mutex);
 
 				worker_str->removed_from_ctx[sched_ctx->id] = 0;
 
 				if(curr_workerid != workerids[i])
-					STARPU_PTHREAD_MUTEX_UNLOCK(&worker_str->sched_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker_str->sched_mutex);
 			}
 		}
 		else
@@ -1069,7 +1069,7 @@ void starpu_sched_ctx_set_priority_on_level(int* workers_to_add, unsigned nworke
 /* 	for(w = 0; w < nworkers_to_add; w++) */
 /* 	{ */
 /* 		worker = _starpu_get_worker_struct(workers_to_add[w]); */
-/* 		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex); */
+/* 		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex); */
 /* 		struct _starpu_sched_ctx_list *l = NULL; */
 /* 		for (l = worker->sched_ctx_list; l; l = l->next) */
 /* 		{ */
@@ -1077,12 +1077,12 @@ void starpu_sched_ctx_set_priority_on_level(int* workers_to_add, unsigned nworke
 /* 			   starpu_sched_ctx_get_hierarchy_level(l->sched_ctx) == starpu_sched_ctx_get_hierarchy_level(sched_ctx)) */
 /* 			{ */
 /* 				/\* the lock is taken inside the func *\/ */
-/* 				STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex); */
+/* 				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex); */
 /* 				starpu_sched_ctx_set_priority(&workers_to_add[w], 1, l->sched_ctx, priority); */
-/* 				STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex); */
+/* 				STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex); */
 /* 			} */
 /* 		} */
-/* 		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex); */
+/* 		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex); */
 /* 	} */
 /* 	return; */
 
@@ -1862,9 +1862,9 @@ void starpu_sched_ctx_set_priority(int *workers, int nworkers, unsigned sched_ct
 		for(w = 0; w < nworkers; w++)
 		{
 			worker = _starpu_get_worker_struct(workers[w]);
-			STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 			_starpu_sched_ctx_list_move(&worker->sched_ctx_list, sched_ctx_id, priority);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 		}
 	}
 	return;
@@ -1982,7 +1982,7 @@ void starpu_sched_ctx_move_task_to_ctx(struct starpu_task *task, unsigned sched_
 	if(workerid != -1 && manage_mutex)
 	{
 		worker = _starpu_get_worker_struct(workerid);
-		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 	}
 
 
@@ -1995,7 +1995,7 @@ void starpu_sched_ctx_move_task_to_ctx(struct starpu_task *task, unsigned sched_
 	_starpu_repush_task(j);
 
 	if(workerid != -1 && manage_mutex)
-		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 }
 
 void starpu_sched_ctx_list_task_counters_increment(unsigned sched_ctx_id, int workerid)
@@ -2005,9 +2005,9 @@ void starpu_sched_ctx_list_task_counters_increment(unsigned sched_ctx_id, int wo
 	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 	if (worker->nsched_ctxs > 1)
 	{
-		STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 		_starpu_sched_ctx_list_push_event(worker->sched_ctx_list, sched_ctx_id);
-		STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 	}
 }
 
@@ -2057,7 +2057,7 @@ void starpu_sched_ctx_list_task_counters_decrement_all(struct starpu_task *task,
 		if(curr_workerid != -1)
 		{
 			curr_worker_str = _starpu_get_worker_struct(curr_workerid);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&curr_worker_str->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&curr_worker_str->sched_mutex);
 		}
 
 		struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
@@ -2073,15 +2073,15 @@ void starpu_sched_ctx_list_task_counters_decrement_all(struct starpu_task *task,
 			worker_str = _starpu_get_worker_struct(worker);
 			if (worker_str->nsched_ctxs > 1)
 			{
-				STARPU_PTHREAD_MUTEX_LOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker_str->sched_mutex);
 				starpu_sched_ctx_list_task_counters_decrement(sched_ctx_id, worker);
-				STARPU_PTHREAD_MUTEX_UNLOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker_str->sched_mutex);
 			}
 		}
 		STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->sched_ctx_list_mutex);
 
 		if(curr_workerid != -1)
-			STARPU_PTHREAD_MUTEX_LOCK(&curr_worker_str->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&curr_worker_str->sched_mutex);
 	}
 }
 
@@ -2094,7 +2094,7 @@ void starpu_sched_ctx_list_task_counters_reset_all(struct starpu_task *task, uns
 		if(curr_workerid != -1)
 		{
 			curr_worker_str = _starpu_get_worker_struct(curr_workerid);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&curr_worker_str->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&curr_worker_str->sched_mutex);
 		}
 
 		struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
@@ -2110,15 +2110,15 @@ void starpu_sched_ctx_list_task_counters_reset_all(struct starpu_task *task, uns
 			worker_str = _starpu_get_worker_struct(worker);
 			if (worker_str->nsched_ctxs > 1)
 			{
-				STARPU_PTHREAD_MUTEX_LOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker_str->sched_mutex);
 				starpu_sched_ctx_list_task_counters_reset(sched_ctx_id, worker);
-				STARPU_PTHREAD_MUTEX_UNLOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker_str->sched_mutex);
 			}
 		}
 		STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->sched_ctx_list_mutex);
 
 		if(curr_workerid != -1)
-			STARPU_PTHREAD_MUTEX_LOCK(&curr_worker_str->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&curr_worker_str->sched_mutex);
 	}
 }
 

src/core/sched_policy.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010-2015  CNRS
  * Copyright (C) 2011  INRIA
  *
@@ -892,7 +892,7 @@ pick:
 	 * We do have a task that uses multiformat handles. Let's create the
 	 * required conversion tasks.
 	 */
-	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 	unsigned i;
 	unsigned nbuffers = STARPU_TASK_GET_NBUFFERS(task);
 	for (i = 0; i < nbuffers; i++)
@@ -916,7 +916,7 @@ pick:
 
 	task->mf_skip = 1;
 	starpu_task_list_push_back(&worker->local_tasks, task);
-	STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 	goto pick;
 
 profiling:
@@ -988,7 +988,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_SCHED(&worker->sched_mutex);
 
 	_starpu_handle_all_pending_node_data_requests(worker->memory_node);
 
@@ -1000,7 +1000,7 @@ void _starpu_wait_on_sched_event(void)
 #endif
 	}
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 }
 
 /* The scheduling policy may put tasks directly into a worker's local queue so

src/core/workers.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2015  Université de Bordeaux
+ * Copyright (C) 2009-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
  * Copyright (C) 2010, 2011  INRIA
  * Copyright (C) 2011  Télécom-SudParis
@@ -2150,7 +2150,7 @@ void _starpu_unlock_mutex_if_prev_locked()
 		struct _starpu_worker *w = _starpu_get_worker_struct(workerid);
 		if(w->sched_mutex_locked)
 		{
-			STARPU_PTHREAD_MUTEX_UNLOCK(&w->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&w->sched_mutex);
 			_starpu_worker_set_flag_sched_mutex_locked(workerid, 1);
 		}
 	}
@@ -2164,7 +2164,7 @@ void _starpu_relock_mutex_if_prev_locked()
 	{
 		struct _starpu_worker *w = _starpu_get_worker_struct(workerid);
 		if(w->sched_mutex_locked)
-			STARPU_PTHREAD_MUTEX_LOCK(&w->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&w->sched_mutex);
 	}
 	return;
 }

src/datawizard/copy_driver.c

@@ -50,9 +50,9 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 		condition  = &descr->conditions_attached_to_node[nodeid][cond_id];
 
 		/* wake anybody waiting on that condition */
-		STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(condition->mutex);
 		STARPU_PTHREAD_COND_BROADCAST(condition->cond);
-		STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(condition->mutex);
 	}
 
 	STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
@@ -78,9 +78,9 @@ void starpu_wake_all_blocked_workers(void)
 		condition  = &descr->conditions_all[cond_id];
 
 		/* wake anybody waiting on that condition */
-		STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(condition->mutex);
 		STARPU_PTHREAD_COND_BROADCAST(condition->cond);
-		STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(condition->mutex);
 	}
 
 	STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);

src/drivers/driver_common/driver_common.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
  * Copyright (C) 2011  Télécom-SudParis
  * Copyright (C) 2014  INRIA
@@ -338,7 +338,7 @@ static void _starpu_exponential_backoff(struct _starpu_worker *worker)
 /* Workers may block when there is no work to do at all. */
 struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int workerid, unsigned memnode)
 {
-	STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 	struct starpu_task *task;
 	unsigned needed = 1;
 	unsigned executing = 0;
@@ -366,7 +366,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 					/* don't let the worker sleep with the sched_mutex taken */
 					/* we need it until here bc of the list of ctxs of the workers
 					   that can change in another thread */
-					STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 					needed = 0;
 					_starpu_sched_ctx_signal_worker_blocked(sched_ctx->id, workerid);
 					sched_ctx->busy[workerid] = 1;
@@ -375,7 +375,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 					STARPU_PTHREAD_COND_SIGNAL(&sched_ctx->parallel_sect_cond_busy[workerid]);
 					_starpu_sched_ctx_signal_worker_woke_up(sched_ctx->id, workerid);
 					sched_ctx->parallel_sect[workerid] = 0;
-					STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+					STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 				}
 				STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->parallel_sect_mutex[workerid]);
 			}
@@ -390,7 +390,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 			if(sched_ctx->parallel_sect[workerid])
 			{
 //				needed = 0;
-				STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 				_starpu_sched_ctx_signal_worker_blocked(sched_ctx->id, workerid);
 				sched_ctx->busy[workerid] = 1;
 				STARPU_PTHREAD_COND_WAIT(&sched_ctx->parallel_sect_cond[workerid], &sched_ctx->parallel_sect_mutex[workerid]);
@@ -398,7 +398,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 				STARPU_PTHREAD_COND_SIGNAL(&sched_ctx->parallel_sect_cond_busy[workerid]);
 				_starpu_sched_ctx_signal_worker_woke_up(sched_ctx->id, workerid);
 				sched_ctx->parallel_sect[workerid] = 0;
-				STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK_SCHED(&worker->sched_mutex);
 			}
 			STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->parallel_sect_mutex[workerid]);
 		}
@@ -435,11 +435,11 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 				)
 		{
 			STARPU_PTHREAD_COND_WAIT(&worker->sched_cond, &worker->sched_mutex);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 		}
 		else
 		{
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 			if (_starpu_machine_is_running())
 			{
 				_starpu_exponential_backoff(worker);
@@ -464,7 +464,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *worker, int w
 	_starpu_worker_set_status_wakeup(workerid);
 	worker->spinning_backoff = BACKOFF_MIN;
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 
 
 #ifdef HAVE_AYUDAME_H
@@ -492,7 +492,7 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 #ifndef STARPU_NON_BLOCKING_DRIVERS
 	/* This assumes only 1 worker */
 	STARPU_ASSERT_MSG(nworkers == 1, "Multiple workers is not yet possible in blocking drivers mode\n");
-	STARPU_PTHREAD_MUTEX_LOCK(&workers[0].sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(&workers[0].sched_mutex);
 #endif
 	for (i = 0; i < nworkers; i++)
 	{
@@ -514,7 +514,7 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 		else
 		{
 #ifdef STARPU_NON_BLOCKING_DRIVERS
-			STARPU_PTHREAD_MUTEX_LOCK(&workers[i].sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(&workers[i].sched_mutex);
 #endif
 			_starpu_worker_set_status_scheduling(workers[i].workerid);
 			_starpu_set_local_worker_key(&workers[i]);
@@ -524,7 +524,7 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 				_starpu_worker_set_status_scheduling_done(workers[i].workerid);
 				_starpu_worker_set_status_wakeup(workers[i].workerid);
 #ifdef STARPU_NON_BLOCKING_DRIVERS
-				STARPU_PTHREAD_MUTEX_UNLOCK(&workers[i].sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&workers[i].sched_mutex);
 #endif
 
 				count ++;
@@ -568,7 +568,7 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 			{
 				_starpu_worker_set_status_sleeping(workers[i].workerid);
 #ifdef STARPU_NON_BLOCKING_DRIVERS
-				STARPU_PTHREAD_MUTEX_UNLOCK(&workers[i].sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&workers[i].sched_mutex);
 #endif
 			}
 		}
@@ -597,11 +597,11 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 				)
 		{
 			STARPU_PTHREAD_COND_WAIT(&worker->sched_cond, &worker->sched_mutex);
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 		}
 		else
 		{
-			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&worker->sched_mutex);
 			if (_starpu_machine_is_running())
 			{
 				_starpu_exponential_backoff(worker);
@@ -623,7 +623,7 @@ int _starpu_get_multi_worker_task(struct _starpu_worker *workers, struct starpu_
 	worker->spinning_backoff = BACKOFF_MIN;
 #endif /* STARPU_SIMGRID */
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(&workers[0].sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(&workers[0].sched_mutex);
 #endif /* !STARPU_NON_BLOCKING_DRIVERS */
 
 	return count;

src/sched_policies/component_worker.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2014, 2015  CNRS
  * Copyright (C) 2011  Télécom-SudParis
  * Copyright (C) 2011-2013  INRIA
@@ -347,7 +347,7 @@ static void _starpu_sched_component_worker_lock_scheduling(unsigned sched_ctx_id
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 	_starpu_sched_component_lock_worker(sched_ctx_id, workerid);	
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 }
 
 static void _starpu_sched_component_worker_unlock_scheduling(unsigned sched_ctx_id)
@@ -356,7 +356,7 @@ static void _starpu_sched_component_worker_unlock_scheduling(unsigned sched_ctx_
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 	_starpu_sched_component_unlock_worker(sched_ctx_id, workerid);	
 }
 
@@ -714,7 +714,7 @@ static int combined_worker_push_task(struct starpu_sched_component * component,
 		starpu_pthread_mutex_t *worker_sched_mutex;
 		starpu_pthread_cond_t *worker_sched_cond;
 		starpu_worker_get_sched_condition(workerid, &worker_sched_mutex, &worker_sched_cond);
-		STARPU_PTHREAD_MUTEX_UNLOCK(worker_sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(worker_sched_mutex);
 
 		/* wake up all other workers of combined worker */
 		for(i = 0; i < combined_worker->worker_size; i++)
@@ -725,7 +725,7 @@ static int combined_worker_push_task(struct starpu_sched_component * component,
 
 		combined_worker_can_pull(component);
 
-		STARPU_PTHREAD_MUTEX_LOCK(worker_sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(worker_sched_mutex);
 	}
 
 	return 0;

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2015  CNRS
  * Copyright (C) 2011  Télécom-SudParis
  * Copyright (C) 2011-2012  INRIA
@@ -290,9 +290,9 @@ static struct starpu_task *dmda_pop_every_task(unsigned sched_ctx_id)
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	new_list = _starpu_fifo_pop_every_task(fifo, workerid);
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 	starpu_sched_ctx_list_task_counters_reset(sched_ctx_id, workerid);
 
@@ -347,7 +347,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 	starpu_sched_ctx_call_pushed_task_cb(best_workerid, sched_ctx_id);
 #endif //STARPU_USE_SC_HYPERVISOR
 
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 
         /* Sometimes workers didn't take the tasks as early as we expected */
 	fifo->exp_start = isnan(fifo->exp_start) ? starpu_timing_now() : STARPU_MAX(fifo->exp_start, starpu_timing_now());
@@ -394,7 +394,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 
 	}
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 	task->predicted = predicted;
 	task->predicted_transfer = predicted_transfer;
@@ -421,7 +421,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 	int ret = 0;
 	if (prio)
 	{
-		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 		ret =_starpu_fifo_push_sorted_task(dt->queue_array[best_workerid], task);
 		if(dt->num_priorities != -1)
 		{
@@ -436,11 +436,11 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		starpu_wakeup_worker_locked(best_workerid, sched_cond, sched_mutex);
 #endif
 		starpu_push_task_end(task);
-		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 	}
 	else
 	{
-		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 		starpu_task_list_push_back (&dt->queue_array[best_workerid]->taskq, task);
 		dt->queue_array[best_workerid]->ntasks++;
 		dt->queue_array[best_workerid]->nprocessed++;
@@ -448,7 +448,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		starpu_wakeup_worker_locked(best_workerid, sched_cond, sched_mutex);
 #endif
 		starpu_push_task_end(task);
-		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 	}
 
 	starpu_sched_ctx_list_task_counters_increment(sched_ctx_id, best_workerid);
@@ -664,9 +664,9 @@ static void compute_all_performance_predictions(struct starpu_task *task,
 					starpu_pthread_mutex_t *sched_mutex;
 					starpu_pthread_cond_t *sched_cond;
 					starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
-					STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+					STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 					prev_exp_len = _starpu_fifo_get_exp_len_prev_task_list(fifo, task, worker, nimpl, &fifo_ntasks);
-					STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 				}
 			}
 				
@@ -1069,7 +1069,7 @@ static void dmda_pre_exec_hook(struct starpu_task *task)
 
 	/* Once the task is executing, we can update the predicted amount
 	 * of work. */
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	if(!isnan(model))
 	{
 		/* We now start the computation, get rid of it in the completion
@@ -1085,7 +1085,7 @@ static void dmda_pre_exec_hook(struct starpu_task *task)
 				fifo->exp_len_per_priority[i] -= model;
 		}
 	}
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 }
 
 static void dmda_push_task_notify(struct starpu_task *task, int workerid, int perf_workerid, unsigned sched_ctx_id)
@@ -1106,7 +1106,7 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, int pe
 
 
 	/* Update the predictions */
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	/* Sometimes workers didn't take the tasks as early as we expected */
 	fifo->exp_start = isnan(fifo->exp_start) ? starpu_timing_now() : STARPU_MAX(fifo->exp_start, starpu_timing_now());
 	fifo->exp_end = fifo->exp_start + fifo->exp_len;
@@ -1164,7 +1164,7 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, int pe
 
 	fifo->ntasks++;
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 }
 
 static void dmda_post_exec_hook(struct starpu_task * task)
@@ -1176,10 +1176,10 @@ static void dmda_post_exec_hook(struct starpu_task * task)
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	fifo->exp_start = starpu_timing_now();
 	fifo->exp_end = fifo->exp_start + fifo->exp_len;
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 }
 
 struct starpu_sched_policy _starpu_sched_dm_policy =

src/sched_policies/eager_central_priority_policy.c

@@ -212,7 +212,7 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 	starpu_pthread_mutex_t *curr_sched_mutex;
 	starpu_pthread_cond_t *curr_sched_cond;
 	starpu_worker_get_sched_condition(workerid, &curr_sched_mutex, &curr_sched_cond);
-	STARPU_PTHREAD_MUTEX_UNLOCK(curr_sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(curr_sched_mutex);
 	
 	/* all workers will block on this mutex anyway so 
 	   there's no need for their own mutex to be locked */
@@ -278,7 +278,7 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
 	/* leave the mutex how it was found before this */
-	STARPU_PTHREAD_MUTEX_LOCK(curr_sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(curr_sched_mutex);
 
 	if(chosen_task)
 	{

src/sched_policies/heteroprio.c

@@ -469,7 +469,7 @@ static struct starpu_task *pop_task_heteroprio_policy(unsigned sched_ctx_id)
 	starpu_worker_get_sched_condition(workerid, &worker_sched_mutex, &worker_sched_cond);
 
 	/* Note: Releasing this mutex before taking the victim mutex, to avoid interlock*/
-	STARPU_PTHREAD_MUTEX_UNLOCK(worker_sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(worker_sched_mutex);
 
 	STARPU_PTHREAD_MUTEX_LOCK(&hp->policy_mutex);
 
@@ -586,7 +586,7 @@ static struct starpu_task *pop_task_heteroprio_policy(unsigned sched_ctx_id)
 					starpu_worker_get_sched_condition(victim, &victim_sched_mutex, &victim_sched_cond);
 
 					/* ensure the worker is not currently prefetching its data */
-					STARPU_PTHREAD_MUTEX_LOCK(victim_sched_mutex);
+					STARPU_PTHREAD_MUTEX_LOCK_SCHED(victim_sched_mutex);
 
 					if(hp->workers_heteroprio[victim].arch_index == worker->arch_index
 					   && hp->workers_heteroprio[victim].tasks_queue->ntasks)
@@ -596,10 +596,10 @@ static struct starpu_task *pop_task_heteroprio_policy(unsigned sched_ctx_id)
 						/* we steal a task update global counter */
 						hp->nb_prefetched_tasks_per_arch_index[hp->workers_heteroprio[victim].arch_index] -= 1;
 
-						STARPU_PTHREAD_MUTEX_UNLOCK(victim_sched_mutex);
+						STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(victim_sched_mutex);
 						goto done;
 					}
-					STARPU_PTHREAD_MUTEX_UNLOCK(victim_sched_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(victim_sched_mutex);
 				}
 			}
 		}
@@ -613,7 +613,7 @@ done:		;
 	}
 	STARPU_PTHREAD_MUTEX_UNLOCK(&hp->policy_mutex);
 
-	STARPU_PTHREAD_MUTEX_LOCK(worker_sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(worker_sched_mutex);
 	if(task)
 	{
 		unsigned child_sched_ctx = starpu_sched_ctx_worker_is_master_for_child_ctx(workerid, sched_ctx_id);

src/sched_policies/parallel_eager.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2011-2015  Université de Bordeaux
+ * Copyright (C) 2011-2016  Université de Bordeaux
  * Copyright (C) 2011  Télécom-SudParis
  * Copyright (C) 2011-2013  INRIA
  *
@@ -260,14 +260,14 @@ static struct starpu_task *pop_task_peager_policy(unsigned sched_ctx_id)
 				starpu_pthread_cond_t *sched_cond;
 				starpu_worker_get_sched_condition(local_worker, &sched_mutex, &sched_cond);
 
-				STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 
 				_starpu_fifo_push_task(data->local_fifo[local_worker], alias);
 
 #if !defined(STARPU_NON_BLOCKING_DRIVERS) || defined(STARPU_SIMGRID)
 				starpu_wakeup_worker_locked(local_worker, sched_cond, sched_mutex);
 #endif
-				STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 			}
 

src/sched_policies/parallel_heft.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2012 INRIA
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -90,12 +90,12 @@ static void parallel_heft_pre_exec_hook(struct starpu_task *task)
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 	/* Once we have executed the task, we can update the predicted amount
 	 * of work. */
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 	worker_exp_len[workerid] -= model + transfer_model;
 	worker_exp_start[workerid] = starpu_timing_now() + model;
 	worker_exp_end[workerid] = worker_exp_start[workerid] + worker_exp_len[workerid];
 	ntasks[workerid]--;
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 }
 
 static int push_task_on_best_worker(struct starpu_task *task, int best_workerid, double exp_end_predicted, int prio, unsigned sched_ctx_id)
@@ -120,7 +120,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		starpu_pthread_cond_t *sched_cond;
 		starpu_worker_get_sched_condition(best_workerid, &sched_mutex, &sched_cond);
 
-		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 		task->predicted = exp_end_predicted - worker_exp_end[best_workerid];
 		/* TODO */
 		task->predicted_transfer = 0;
@@ -129,7 +129,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		worker_exp_start[best_workerid] = exp_end_predicted - worker_exp_len[best_workerid];
 
 		ntasks[best_workerid]++;
-		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 		/* We don't want it to interlace its task with a combined
 		 * worker's one */
@@ -169,13 +169,13 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 			starpu_pthread_mutex_t *sched_mutex;
 			starpu_pthread_cond_t *sched_cond;
 			starpu_worker_get_sched_condition(local_worker, &sched_mutex, &sched_cond);
-			STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 			worker_exp_len[local_worker] += alias->predicted;
 			worker_exp_end[local_worker] = exp_end_predicted;
 			worker_exp_start[local_worker] = exp_end_predicted - worker_exp_len[local_worker];
 
 			ntasks[local_worker]++;
-			STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 			ret |= starpu_push_local_task(local_worker, alias, prio);
 		}
@@ -320,12 +320,12 @@ static int _parallel_heft_push_task(struct starpu_task *task, unsigned prio, uns
 			starpu_pthread_cond_t *sched_cond;
 			starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
 			/* Sometimes workers didn't take the tasks as early as we expected */
-			STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 			worker_exp_start[worker] = STARPU_MAX(worker_exp_start[worker], starpu_timing_now());
 			worker_exp_end[worker] = worker_exp_start[worker] + worker_exp_len[worker];
 			if (worker_exp_end[worker] > max_exp_end)
 				max_exp_end = worker_exp_end[worker];
-			STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 		}
 	}
 

src/sched_policies/stack_queues.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2013  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -88,9 +88,9 @@ struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queu
 
 		/* we are sure that we got it now, so at worst, some people thought
 		 * there remained some work and will soon discover it is not true */
-		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 		total_number_of_jobs--;
-		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 	}
 
 	return j;

src/sched_policies/work_stealing_policy.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2015  Université de Bordeaux
+ * Copyright (C) 2010-2016  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013  CNRS
  * Copyright (C) 2011, 2012  INRIA
  *
@@ -279,7 +279,7 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 	starpu_worker_get_sched_condition(workerid, &worker_sched_mutex, &worker_sched_cond);
 
 	/* Note: Releasing this mutex before taking the victim mutex, to avoid interlock*/
-	STARPU_PTHREAD_MUTEX_UNLOCK(worker_sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(worker_sched_mutex);
        
 
 	/* we need to steal someone's job */
@@ -289,7 +289,7 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 	starpu_pthread_cond_t *victim_sched_cond;
 
 	starpu_worker_get_sched_condition(victim, &victim_sched_mutex, &victim_sched_cond);
-	STARPU_PTHREAD_MUTEX_LOCK(victim_sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(victim_sched_mutex);
 
 	task = _starpu_fifo_pop_task(ws->queue_array[victim], workerid);
 	if (task)
@@ -297,9 +297,9 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 		_STARPU_TRACE_WORK_STEALING(workerid, victim);
 	}
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(victim_sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(victim_sched_mutex);
 
-	STARPU_PTHREAD_MUTEX_LOCK(worker_sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(worker_sched_mutex);
 	if(!task)
 	{
 		task = _starpu_fifo_pop_task(ws->queue_array[workerid], workerid);
@@ -330,7 +330,7 @@ int ws_push_task(struct starpu_task *task)
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
-	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK_SCHED(sched_mutex);
 
 #ifdef HAVE_AYUDAME_H
 	struct _starpu_job *j = _starpu_get_job_associated_to_task(task);
@@ -345,7 +345,7 @@ int ws_push_task(struct starpu_task *task)
 
 	starpu_push_task_end(task);
 
-	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(sched_mutex);
 
 #if !defined(STARPU_NON_BLOCKING_DRIVERS) || defined(STARPU_SIMGRID)
 	/* TODO: implement fine-grain signaling, similar to what eager does */