merge trunk -r 9571:9579

Makefile.am

@@ -79,7 +79,8 @@ versinclude_HEADERS = 				\
 	include/starpu_cublas.h			\
 	include/starpu_driver.h			\
 	include/starpu_stdlib.h			\
-	include/starpu_thread.h
+	include/starpu_thread.h			\
+	include/starpu_thread_util.h
 
 nodist_versinclude_HEADERS = 			\
 	include/starpu_config.h

doc/chapters/api.texi

@@ -2297,6 +2297,16 @@ Output on @code{stderr} some statistics on the codelet @var{cl}.
 This function waits until there is no more ready task.
 @end deftypefun
 
+@deftypefun void starpu_task_set_implementation ({struct starpu_task *}@var{task}, unsigned @var{impl})
+This function should be called by schedulers to specify the codelet
+implementation to be executed when executing the task.
+@end deftypefun
+
+@deftypefun unsigned starpu_task_get_implementation ({struct starpu_task *}@var{task})
+This function return the codelet implementation to be executed when
+executing the task.
+@end deftypefun
+
 @c Callbacks: what can we put in callbacks ?
 
 @node Insert Task

include/starpu.h

@@ -42,6 +42,7 @@ typedef UINT_PTR uintptr_t;
 #endif
 
 #include <starpu_thread.h>
+#include <starpu_thread_util.h>
 #include <starpu_util.h>
 #include <starpu_data.h>
 #include <starpu_data_interfaces.h>

include/starpu_task.h

@@ -360,6 +360,9 @@ void starpu_parallel_task_barrier_init(struct starpu_task* task, int workerid);
 /* duplicate the given task */
 struct starpu_task *starpu_task_dup(struct starpu_task *task);
 
+void starpu_task_set_implementation(struct starpu_task *task, unsigned impl);
+unsigned starpu_task_get_implementation(struct starpu_task *task);
+
 #ifdef __cplusplus
 }
 #endif

include/starpu_thread.h

@@ -39,6 +39,7 @@ extern "C"
 typedef int starpu_pthread_t;
 typedef int starpu_pthread_attr_t;
 
+int starpu_pthread_create_on(char *name, starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg, int where);
 int starpu_pthread_create(starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
 int starpu_pthread_join(starpu_pthread_t thread, void **retval);
 int starpu_pthread_attr_init(starpu_pthread_attr_t *attr);
@@ -51,6 +52,7 @@ typedef pthread_t starpu_pthread_t;
 typedef pthread_attr_t starpu_pthread_attr_t;
 
 #define starpu_pthread_create pthread_create
+#define starpu_pthread_create_on(name, thread, attr, routine, arg, where) starpu_pthread_create(thread, attr, routine, arg)
 #define starpu_pthread_join pthread_join
 #define starpu_pthread_attr_init pthread_attr_init
 #define starpu_pthread_attr_destroy pthread_attr_destroy

include/starpu_thread_util.h

@@ -0,0 +1,263 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2010, 2012-2013  Université de Bordeaux 1
+ * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#ifndef __STARPU_THREAD_UTIL_H__
+#define __STARPU_THREAD_UTIL_H__
+
+#include <starpu.h>
+
+/*
+ * Encapsulation of the starpu_pthread_create_* functions.
+ */
+
+#define STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, where) do {		    		\
+	int p_ret =  starpu_pthread_create_on((name), (thread), (attr), (routine), (arg), (where)); 	\
+	if (STARPU_UNLIKELY(p_ret != 0)) {								\
+		fprintf(stderr,										\
+			"%s:%d starpu_pthread_create_on: %s\n",						\
+			__FILE__, __LINE__, strerror(p_ret));						\
+		STARPU_ABORT();										\
+	}												\
+} while (0)
+
+#define STARPU_PTHREAD_CREATE(thread, attr, routine, arg) do {		    	\
+	int p_ret =  starpu_pthread_create((thread), (attr), (routine), (arg)); \
+	if (STARPU_UNLIKELY(p_ret != 0)) {					\
+		fprintf(stderr,							\
+			"%s:%d starpu_pthread_create: %s\n",			\
+			__FILE__, __LINE__, strerror(p_ret));			\
+		STARPU_ABORT();							\
+	}									\
+} while (0)
+
+/*
+ * Encapsulation of the starpu_pthread_mutex_* functions.
+ */
+
+#define STARPU_PTHREAD_MUTEX_INIT(mutex, attr) do {                           \
+	int p_ret = starpu_pthread_mutex_init((mutex), (attr));                \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_mutex_init: %s\n",               \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_MUTEX_DESTROY(mutex) do {                              \
+	int p_ret = starpu_pthread_mutex_destroy(mutex);                       \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_mutex_destroy: %s\n",            \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while(0)
+
+#define STARPU_PTHREAD_MUTEX_LOCK(mutex) do {                                 \
+	int p_ret = starpu_pthread_mutex_lock(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_UNLOCK(mutex) do {                               \
+	int p_ret = starpu_pthread_mutex_unlock(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)
+
+/*
+ * Encapsulation of the starpu_pthread_key_* functions.
+ */
+#define STARPU_PTHREAD_KEY_CREATE(key, destr) do {                            \
+	int p_ret = starpu_pthread_key_create((key), (destr));	               \
+	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_key_create: %s\n",               \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_KEY_DELETE(key) do {                                   \
+	int p_ret = starpu_pthread_key_delete((key));	                       \
+	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_key_delete: %s\n",               \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_SETSPECIFIC(key, ptr) do {                             \
+	int p_ret = starpu_pthread_setspecific((key), (ptr));	               \
+	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_setspecific: %s\n",              \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+	};                                                                     \
+} while (0)
+
+#define STARPU_PTHREAD_GETSPECIFIC(key) starpu_pthread_getspecific((key))
+
+/*
+ * Encapsulation of the starpu_pthread_rwlock_* functions.
+ */
+#define STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) do {                          \
+	int p_ret = starpu_pthread_rwlock_init((rwlock), (attr));              \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_rwlock_init: %s\n",              \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) do {                              \
+	int p_ret = starpu_pthread_rwlock_rdlock(rwlock);                      \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_rwlock_rdlock: %s\n",            \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) do {                              \
+	int p_ret = starpu_pthread_rwlock_wrlock(rwlock);                      \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_rwlock_wrlock: %s\n",            \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) do {                              \
+	int p_ret = starpu_pthread_rwlock_unlock(rwlock);                      \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_rwlock_unlock: %s\n",            \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) do {                            \
+	int p_ret = starpu_pthread_rwlock_destroy(rwlock);                     \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_rwlock_destroy: %s\n",           \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+/*
+ * Encapsulation of the starpu_pthread_cond_* functions.
+ */
+#define STARPU_PTHREAD_COND_INIT(cond, attr) do {                             \
+	int p_ret = starpu_pthread_cond_init((cond), (attr));                  \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_cond_init: %s\n",                \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_COND_DESTROY(cond) do {                                \
+	int p_ret = starpu_pthread_cond_destroy(cond);                         \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_cond_destroy: %s\n",             \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+			STARPU_ABORT();                                        \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_COND_SIGNAL(cond) do {                                 \
+	int p_ret = starpu_pthread_cond_signal(cond);                          \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_cond_signal: %s\n",              \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_COND_BROADCAST(cond) do {                              \
+	int p_ret = starpu_pthread_cond_broadcast(cond);                       \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_cond_broadcast: %s\n",           \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_COND_WAIT(cond, mutex) do {                            \
+	int p_ret = starpu_pthread_cond_wait((cond), (mutex));                 \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d starpu_pthread_cond_wait: %s\n",                \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+/*
+ * Encapsulation of the starpu_pthread_barrier_* functions.
+ */
+
+#define STARPU_PTHREAD_BARRIER_INIT(barrier, attr, count) do {                \
+	int p_ret = pthread_barrier_init((barrier), (attr), (count));          \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d pthread_barrier_init: %s\n",                    \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_BARRIER_DESTROY(barrier) do {                          \
+	int p_ret = pthread_barrier_destroy((barrier));                        \
+	if (STARPU_UNLIKELY(p_ret)) {                                          \
+		fprintf(stderr,                                                \
+			"%s:%d pthread_barrier_destroy: %s\n",                 \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while (0)
+
+#define STARPU_PTHREAD_BARRIER_WAIT(barrier) do {                             \
+	int p_ret = pthread_barrier_wait(barrier);                             \
+	if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == PTHREAD_BARRIER_SERIAL_THREAD)))) { \
+		fprintf(stderr,                                                \
+			"%s:%d pthread_barrier_wait: %s\n",                    \
+			__FILE__, __LINE__, strerror(p_ret));                  \
+			STARPU_ABORT();                                        \
+	}                                                                      \
+} while (0)
+
+#endif /* __STARPU_THREAD_UTIL_H__ */

mpi/src/starpu_mpi.c

@@ -55,7 +55,7 @@ static int running = 0;
 static starpu_pthread_mutex_t mutex_posted_requests;
 static int posted_requests = 0, newer_requests, barrier_running = 0;
 
-#define _STARPU_MPI_INC_POSTED_REQUESTS(value) { _STARPU_PTHREAD_MUTEX_LOCK(&mutex_posted_requests); posted_requests += value; _STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_posted_requests); }
+#define _STARPU_MPI_INC_POSTED_REQUESTS(value) { STARPU_PTHREAD_MUTEX_LOCK(&mutex_posted_requests); posted_requests += value; STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_posted_requests); }
 
 struct _starpu_mpi_envelope
 {
@@ -198,8 +198,8 @@ static struct _starpu_mpi_req *_starpu_mpi_isend_irecv_common(starpu_data_handle
 	/* Initialize the request structure */
 	req->submitted = 0;
 	req->completed = 0;
-	_STARPU_PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&req->req_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&req->req_cond, NULL);
 
 	req->request_type = request_type;
 	req->user_datatype = -1;
@@ -248,10 +248,10 @@ static void _starpu_mpi_isend_data_func(struct _starpu_mpi_req *req)
 	TRACE_MPI_ISEND_SUBMIT_END(req->srcdst, req->mpi_tag, 0);
 
 	/* somebody is perhaps waiting for the MPI request to be posted */
-	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	_starpu_mpi_handle_detached_request(req);
 
@@ -380,10 +380,10 @@ static void _starpu_mpi_irecv_data_func(struct _starpu_mpi_req *req)
 	TRACE_MPI_IRECV_SUBMIT_END(req->srcdst, req->mpi_tag);
 
 	/* somebody is perhaps waiting for the MPI request to be posted */
-	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	_starpu_mpi_handle_detached_request(req);
 
@@ -465,14 +465,14 @@ int starpu_mpi_wait(starpu_mpi_req *public_req, MPI_Status *status)
 
 	/* We cannot try to complete a MPI request that was not actually posted
 	 * to MPI yet. */
-	_STARPU_PTHREAD_MUTEX_LOCK(&(req->req_mutex));
+	STARPU_PTHREAD_MUTEX_LOCK(&(req->req_mutex));
 	while (!(req->submitted))
-		_STARPU_PTHREAD_COND_WAIT(&(req->req_cond), &(req->req_mutex));
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&(req->req_mutex));
+		STARPU_PTHREAD_COND_WAIT(&(req->req_cond), &(req->req_mutex));
+	STARPU_PTHREAD_MUTEX_UNLOCK(&(req->req_mutex));
 
 	/* Initialize the request structure */
-	_STARPU_PTHREAD_MUTEX_INIT(&(waiting_req->req_mutex), NULL);
-	_STARPU_PTHREAD_COND_INIT(&(waiting_req->req_cond), NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&(waiting_req->req_mutex), NULL);
+	STARPU_PTHREAD_COND_INIT(&(waiting_req->req_cond), NULL);
 	waiting_req->status = status;
 	waiting_req->other_request = req;
 	waiting_req->func = _starpu_mpi_wait_func;
@@ -481,10 +481,10 @@ int starpu_mpi_wait(starpu_mpi_req *public_req, MPI_Status *status)
 	_starpu_mpi_submit_new_mpi_request(waiting_req);
 
 	/* We wait for the MPI request to finish */
-	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	while (!req->completed)
-		_STARPU_PTHREAD_COND_WAIT(&req->req_cond, &req->req_mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+		STARPU_PTHREAD_COND_WAIT(&req->req_cond, &req->req_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	ret = req->ret;
 
@@ -525,10 +525,10 @@ static void _starpu_mpi_test_func(struct _starpu_mpi_req *testing_req)
 		_starpu_mpi_handle_request_termination(req);
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&testing_req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&testing_req->req_mutex);
 	testing_req->completed = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&testing_req->req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&testing_req->req_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&testing_req->req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&testing_req->req_mutex);
 	_STARPU_MPI_LOG_OUT();
 }
 
@@ -543,9 +543,9 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
 
 	STARPU_ASSERT_MSG(!req->detached, "MPI_Test cannot be called on a detached request");
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	unsigned submitted = req->submitted;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	if (submitted)
 	{
@@ -554,8 +554,8 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
 		//		memset(testing_req, 0, sizeof(struct _starpu_mpi_req));
 
 		/* Initialize the request structure */
-		_STARPU_PTHREAD_MUTEX_INIT(&(testing_req->req_mutex), NULL);
-		_STARPU_PTHREAD_COND_INIT(&(testing_req->req_cond), NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&(testing_req->req_mutex), NULL);
+		STARPU_PTHREAD_COND_INIT(&(testing_req->req_cond), NULL);
 		testing_req->flag = flag;
 		testing_req->status = status;
 		testing_req->other_request = req;
@@ -567,10 +567,10 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
 		_starpu_mpi_submit_new_mpi_request(testing_req);
 
 		/* We wait for the test request to finish */
-		_STARPU_PTHREAD_MUTEX_LOCK(&(testing_req->req_mutex));
+		STARPU_PTHREAD_MUTEX_LOCK(&(testing_req->req_mutex));
 		while (!(testing_req->completed))
-			_STARPU_PTHREAD_COND_WAIT(&(testing_req->req_cond), &(testing_req->req_mutex));
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&(testing_req->req_mutex));
+			STARPU_PTHREAD_COND_WAIT(&(testing_req->req_cond), &(testing_req->req_mutex));
+		STARPU_PTHREAD_MUTEX_UNLOCK(&(testing_req->req_mutex));
 
 		ret = testing_req->ret;
 
@@ -621,30 +621,30 @@ int starpu_mpi_barrier(MPI_Comm comm)
 	/* First wait for *both* all tasks and MPI requests to finish, in case
 	 * some tasks generate MPI requests, MPI requests generate tasks, etc.
 	 */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	STARPU_ASSERT_MSG(!barrier_running, "Concurrent starpu_mpi_barrier is not implemented, even on different communicators");
 	barrier_running = 1;
 	do
 	{
 		while (posted_requests)
 			/* Wait for all current MPI requests to finish */
-			_STARPU_PTHREAD_COND_WAIT(&cond_finished, &mutex);
+			STARPU_PTHREAD_COND_WAIT(&cond_finished, &mutex);
 		/* No current request, clear flag */
 		newer_requests = 0;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		/* Now wait for all tasks */
 		starpu_task_wait_for_all();
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		/* Check newer_requests again, in case some MPI requests
 		 * triggered by tasks completed and triggered tasks between
 		 * wait_for_all finished and we take the lock */
 	} while (posted_requests || newer_requests);
 	barrier_running = 0;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	/* Initialize the request structure */
-	_STARPU_PTHREAD_MUTEX_INIT(&(barrier_req->req_mutex), NULL);
-	_STARPU_PTHREAD_COND_INIT(&(barrier_req->req_cond), NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&(barrier_req->req_mutex), NULL);
+	STARPU_PTHREAD_COND_INIT(&(barrier_req->req_cond), NULL);
 	barrier_req->func = _starpu_mpi_barrier_func;
 	barrier_req->request_type = BARRIER_REQ;
 	barrier_req->comm = comm;
@@ -653,10 +653,10 @@ int starpu_mpi_barrier(MPI_Comm comm)
 	_starpu_mpi_submit_new_mpi_request(barrier_req);
 
 	/* We wait for the MPI request to finish */
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier_req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier_req->req_mutex);
 	while (!barrier_req->completed)
-		_STARPU_PTHREAD_COND_WAIT(&barrier_req->req_cond, &barrier_req->req_mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier_req->req_mutex);
+		STARPU_PTHREAD_COND_WAIT(&barrier_req->req_cond, &barrier_req->req_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier_req->req_mutex);
 
 	ret = barrier_req->ret;
 
@@ -737,10 +737,10 @@ static void _starpu_mpi_handle_request_termination(struct _starpu_mpi_req *req)
 
 	/* tell anyone potentially waiting on the request that it is
 	 * terminated now */
-	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->completed = 1;
-	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 	_STARPU_MPI_LOG_OUT();
 }
 
@@ -789,7 +789,7 @@ static void _starpu_mpi_submit_new_mpi_request(void *arg)
 
 	_STARPU_MPI_INC_POSTED_REQUESTS(-1);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	if (req->request_type == RECV_REQ)
 	{
@@ -847,7 +847,7 @@ static void _starpu_mpi_submit_new_mpi_request(void *arg)
 			}
 
 			newer_requests = 1;
-			_STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
+			STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
 		}
 	}
 	else
@@ -857,10 +857,10 @@ static void _starpu_mpi_submit_new_mpi_request(void *arg)
 		newer_requests = 1;
 		_STARPU_MPI_DEBUG(3, "Pushing new request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d user_datatype %d \n",
 				  req, _starpu_mpi_request_type(req->request_type), req->mpi_tag, req->srcdst, req->data_handle, req->ptr, _starpu_mpi_datatype(req->datatype), (int)req->count, req->user_datatype);
-		_STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
+		STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	_STARPU_MPI_LOG_OUT();
 }
 
@@ -869,13 +869,13 @@ static unsigned _starpu_mpi_progression_hook_func(void *arg __attribute__((unuse
 {
 	unsigned may_block = 1;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!_starpu_mpi_req_list_empty(detached_requests))
 	{
-		_STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
+		STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
 		may_block = 0;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return may_block;
 }
@@ -888,7 +888,7 @@ static void _starpu_mpi_test_detached_requests(void)
 	MPI_Status status;
 	struct _starpu_mpi_req *req, *next_req;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
 
 	for (req = _starpu_mpi_req_list_begin(detached_requests);
 		req != _starpu_mpi_req_list_end(detached_requests);
@@ -896,7 +896,7 @@ static void _starpu_mpi_test_detached_requests(void)
 	{
 		next_req = _starpu_mpi_req_list_next(req);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
 
 		//_STARPU_MPI_DEBUG(3, "Test detached request %p - mpitag %d - TYPE %s %d\n", &req->request, req->mpi_tag, _starpu_mpi_request_type(req->request_type), req->srcdst);
 		req->ret = MPI_Test(&req->request, &flag, &status);
@@ -926,7 +926,7 @@ static void _starpu_mpi_test_detached_requests(void)
 			}
 		}
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
 
 		if (flag)
 		{
@@ -936,7 +936,7 @@ static void _starpu_mpi_test_detached_requests(void)
 
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
 	_STARPU_MPI_LOG_OUT();
 }
 
@@ -944,17 +944,17 @@ static void _starpu_mpi_handle_detached_request(struct _starpu_mpi_req *req)
 {
 	if (req->detached)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		_starpu_mpi_req_list_push_front(detached_requests, req);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		starpu_wake_all_blocked_workers();
 
 		/* put the submitted request into the list of pending requests
 		 * so that it can be handled by the progression mechanisms */
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
-		_STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -1032,12 +1032,12 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 	}
 
 	/* notify the main thread that the progression thread is ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	running = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&cond_progression);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
  	struct _starpu_mpi_envelope *recv_env = calloc(1,sizeof(struct _starpu_mpi_envelope));
 
@@ -1062,8 +1062,8 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 
 			if (barrier_running)
 				/* Tell mpi_barrier */
-				_STARPU_PTHREAD_COND_SIGNAL(&cond_finished);
-			_STARPU_PTHREAD_COND_WAIT(&cond_progression, &mutex);
+				STARPU_PTHREAD_COND_SIGNAL(&cond_finished);
+			STARPU_PTHREAD_COND_WAIT(&cond_progression, &mutex);
 
 			TRACE_MPI_SLEEP_END();
 		}
@@ -1078,9 +1078,9 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 			 * (on a sync_data_with_mem call), we want to let the
 			 * application submit requests in the meantime, so we
 			 * release the lock. */
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 			_starpu_mpi_handle_new_request(req);
-			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		}
 
 		/* If there is no currently submitted header_req submitted to catch envelopes from senders, and there is some pending receive
@@ -1094,9 +1094,9 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 		}
 
 		/* test whether there are some terminated "detached request" */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		_starpu_mpi_test_detached_requests();
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		if (header_req_submitted == 1)
 		{
@@ -1173,9 +1173,9 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 					 * (on a sync_data_with_mem call), we want to let the
 					 * application submit requests in the meantime, so we
 					 * release the lock. */
-					_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 					_starpu_mpi_handle_new_request(found_req);
-					_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+					STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 				}
 				header_req_submitted = 0;
 			}
@@ -1197,7 +1197,7 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 		MPI_Finalize();
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	free(argc_argv);
 	free(recv_env);
@@ -1252,27 +1252,27 @@ static void _starpu_mpi_add_sync_point_in_fxt(void)
 static
 int _starpu_mpi_initialize(int *argc, char ***argv, int initialize_mpi)
 {
-	_STARPU_PTHREAD_MUTEX_INIT(&mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&cond_progression, NULL);
-	_STARPU_PTHREAD_COND_INIT(&cond_finished, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&cond_progression, NULL);
+	STARPU_PTHREAD_COND_INIT(&cond_finished, NULL);
 	new_requests = _starpu_mpi_req_list_new();
 
-	_STARPU_PTHREAD_MUTEX_INIT(&detached_requests_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&detached_requests_mutex, NULL);
 	detached_requests = _starpu_mpi_req_list_new();
 
-	_STARPU_PTHREAD_MUTEX_INIT(&mutex_posted_requests, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&mutex_posted_requests, NULL);
 
 	struct _starpu_mpi_argc_argv *argc_argv = malloc(sizeof(struct _starpu_mpi_argc_argv));
 	argc_argv->initialize_mpi = initialize_mpi;
 	argc_argv->argc = argc;
 	argc_argv->argv = argv;
 
-	_STARPU_PTHREAD_CREATE("MPI progress", &progress_thread, NULL, _starpu_mpi_progress_thread_func, argc_argv);
+	STARPU_PTHREAD_CREATE(&progress_thread, NULL, _starpu_mpi_progress_thread_func, argc_argv);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (!running)
-		_STARPU_PTHREAD_COND_WAIT(&cond_progression, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond_progression, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 #ifdef STARPU_MPI_ACTIVITY
 	hookid = starpu_progression_hook_register(progression_hook_func, NULL);
@@ -1319,10 +1319,10 @@ int starpu_mpi_shutdown(void)
 	MPI_Comm_size(MPI_COMM_WORLD, &world_size);
 
 	/* kill the progression thread */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	running = 0;
-	_STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_pthread_join(progress_thread, &value);
 

mpi/tests/mpi_irecv_detached.c

@@ -36,10 +36,10 @@ void callback(void *arg __attribute__((unused)))
 {
 	unsigned *received = arg;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	*received = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 
@@ -84,10 +84,10 @@ int main(int argc, char **argv)
 			int received = 0;
 			starpu_mpi_irecv_detached(tab_handle, other_rank, loop, MPI_COMM_WORLD, callback, &received);
 
-			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 			while (!received)
-				_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+				STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		}
 	}
 

mpi/tests/mpi_isend_detached.c

@@ -34,10 +34,10 @@ void callback(void *arg)
 {
 	unsigned *completed = arg;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	*completed = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -79,20 +79,20 @@ int main(int argc, char **argv)
 			int sent = 0;
 			starpu_mpi_isend_detached(tab_handle, other_rank, loop, MPI_COMM_WORLD, callback, &sent);
 
-			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 			while (!sent)
-				_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+				STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		}
 		else
 		{
 			int received = 0;
 			starpu_mpi_irecv_detached(tab_handle, other_rank, loop, MPI_COMM_WORLD, callback, &received);
 
-			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 			while (!received)
-				_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+				STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		}
 	}
 

src/common/barrier.c

@@ -23,9 +23,9 @@ int _starpu_barrier_init(struct _starpu_barrier *barrier, int count)
 	barrier->count = count;
 	barrier->reached_start = 0;
 	barrier->reached_exit = 0;
-	_STARPU_PTHREAD_MUTEX_INIT(&barrier->mutex, NULL);
-	_STARPU_PTHREAD_MUTEX_INIT(&barrier->mutex_exit, NULL);
-	_STARPU_PTHREAD_COND_INIT(&barrier->cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&barrier->mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&barrier->mutex_exit, NULL);
+	STARPU_PTHREAD_COND_INIT(&barrier->cond, NULL);
 	return 0;
 }
 
@@ -36,13 +36,13 @@ int _starpu_barrier_test(struct _starpu_barrier *barrier)
 	 * Check whether any threads are known to be waiting; report
 	 * "BUSY" if so.
 	 */
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
 	if (barrier->reached_exit != barrier->count)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
 		return EBUSY;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
 	return 0;
 }
 
@@ -55,9 +55,9 @@ int _starpu_barrier_destroy(struct _starpu_barrier *barrier)
 	}
 	_STARPU_DEBUG("reached_exit %d\n", barrier->reached_exit);
 
-	_STARPU_PTHREAD_MUTEX_DESTROY(&barrier->mutex);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&barrier->mutex_exit);
-	_STARPU_PTHREAD_COND_DESTROY(&barrier->cond);
+	STARPU_PTHREAD_MUTEX_DESTROY(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&barrier->mutex_exit);
+	STARPU_PTHREAD_COND_DESTROY(&barrier->cond);
 	return 0;
 }
 
@@ -66,25 +66,25 @@ int _starpu_barrier_wait(struct _starpu_barrier *barrier)
 	int ret=0;
 
 	// Wait until all threads enter the barrier
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 	barrier->reached_exit=0;
 	barrier->reached_start++;
 	if (barrier->reached_start == barrier->count)
 	{
 		barrier->reached_start = 0;
-		_STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
+		STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
 		ret = PTHREAD_BARRIER_SERIAL_THREAD;
 	}
 	else
 	{
-		_STARPU_PTHREAD_COND_WAIT(&barrier->cond,&barrier->mutex);
+		STARPU_PTHREAD_COND_WAIT(&barrier->cond,&barrier->mutex);
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 
 	// Count number of threads that exit the barrier
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
 	barrier->reached_exit ++;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
 
 	return ret;
 }

src/common/barrier_counter.c

@@ -20,14 +20,14 @@
 int _starpu_barrier_counter_init(struct _starpu_barrier_counter *barrier_c, int count)
 {
 	_starpu_barrier_init(&barrier_c->barrier, count);
-	_STARPU_PTHREAD_COND_INIT(&barrier_c->cond2, NULL);
+	STARPU_PTHREAD_COND_INIT(&barrier_c->cond2, NULL);
 	return 0;
 }
 
 int _starpu_barrier_counter_destroy(struct _starpu_barrier_counter *barrier_c)
 {
 	_starpu_barrier_destroy(&barrier_c->barrier);
-	_STARPU_PTHREAD_COND_DESTROY(&barrier_c->cond2);
+	STARPU_PTHREAD_COND_DESTROY(&barrier_c->cond2);
 	return 0;
 }
 
@@ -35,24 +35,24 @@ int _starpu_barrier_counter_destroy(struct _starpu_barrier_counter *barrier_c)
 int _starpu_barrier_counter_wait_for_empty_counter(struct _starpu_barrier_counter *barrier_c)
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	while (barrier->reached_start > 0)
-		_STARPU_PTHREAD_COND_WAIT(&barrier->cond, &barrier->mutex);
+		STARPU_PTHREAD_COND_WAIT(&barrier->cond, &barrier->mutex);
 
-	_STARPU_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 *barrier_c)
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	while (barrier->reached_start < barrier->count)
-		_STARPU_PTHREAD_COND_WAIT(&barrier_c->cond2, &barrier->mutex);
+		STARPU_PTHREAD_COND_WAIT(&barrier_c->cond2, &barrier->mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 
@@ -60,15 +60,15 @@ int _starpu_barrier_counter_decrement_until_empty_counter(struct _starpu_barrier
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
 	int ret = 0;
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	if (--barrier->reached_start == 0)
 	{
 		ret = 1;
-		_STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
+		STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return ret;
 }
 
@@ -76,26 +76,26 @@ int _starpu_barrier_counter_increment_until_full_counter(struct _starpu_barrier_
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
 	int ret = 0;
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
-	
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+
 	if(++barrier->reached_start == barrier->count)
 	{
 		ret = 1;
-		_STARPU_PTHREAD_COND_BROADCAST(&barrier_c->cond2);
+		STARPU_PTHREAD_COND_BROADCAST(&barrier_c->cond2);
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return ret;
 }
 
 int _starpu_barrier_counter_increment(struct _starpu_barrier_counter *barrier_c)
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
-	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	barrier->reached_start++;
-	
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+
+	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 	return 0;
 }
 

src/common/thread.c

@@ -27,7 +27,7 @@
 
 extern int _starpu_simgrid_thread_start(int argc, char *argv[]);
 
-int _starpu_pthread_create_on(char *name, starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg, int where)
+int starpu_pthread_create_on(char *name, starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg, int where)
 {
 	struct _starpu_pthread_args *_args = malloc(sizeof(*_args));
 	xbt_dynar_t _hosts;
@@ -40,9 +40,9 @@ int _starpu_pthread_create_on(char *name, starpu_pthread_t *thread, const starpu
 	return 0;
 }
 
-int starpu_pthread_create(starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)
+int starpu_pthread_create(char *name, starpu_pthread_t *thread, const starpu_pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)
 {
-	return _starpu_pthread_create_on("", thread, attr, start_routine, arg, 0);
+	return starpu_pthread_create_on(name, thread, attr, start_routine, arg, 0);
 }
 
 int starpu_pthread_join(starpu_pthread_t thread, void **retval)
@@ -84,7 +84,7 @@ int starpu_pthread_mutex_destroy(starpu_pthread_mutex_t *mutex)
 
 int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex)
 {
-	if (!*mutex) _STARPU_PTHREAD_MUTEX_INIT(mutex, NULL);
+	if (!*mutex) STARPU_PTHREAD_MUTEX_INIT(mutex, NULL);
 	xbt_mutex_acquire(*mutex);
 	return 0;
 }
@@ -147,7 +147,7 @@ int starpu_pthread_cond_init(starpu_pthread_cond_t *cond, starpu_pthread_condatt
 int starpu_pthread_cond_signal(starpu_pthread_cond_t *cond)
 {
 	if (!*cond)
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+		STARPU_PTHREAD_COND_INIT(cond, NULL);
 	xbt_cond_signal(*cond);
 	return 0;
 }
@@ -155,7 +155,7 @@ int starpu_pthread_cond_signal(starpu_pthread_cond_t *cond)
 int starpu_pthread_cond_broadcast(starpu_pthread_cond_t *cond)
 {
 	if (!*cond)
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+		STARPU_PTHREAD_COND_INIT(cond, NULL);
 	xbt_cond_broadcast(*cond);
 	return 0;
 }
@@ -163,7 +163,7 @@ int starpu_pthread_cond_broadcast(starpu_pthread_cond_t *cond)
 int starpu_pthread_cond_wait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex)
 {
 	if (!*cond)
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+		STARPU_PTHREAD_COND_INIT(cond, NULL);
 	xbt_cond_wait(*cond, *mutex);
 	return 0;
 }

src/common/thread.h

@@ -20,241 +20,8 @@
 
 #include <starpu.h>
 
-/*
- * Encapsulation of the starpu_pthread_create_* functions.
- */
-
-#define _STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, where) do {		\
-	int p_ret =  starpu_pthread_create((thread), (attr), (routine), (arg));		\
-	if (STARPU_UNLIKELY(p_ret != 0)) {						\
-		fprintf(stderr,                         		                \
-			"%s:%d starpu_pthread_create: %s\n",                   		\
-			__FILE__, __LINE__, strerror(p_ret));                  		\
-	}                                                                      		\
-} while (0)
-
-#define _STARPU_PTHREAD_CREATE(name, thread, attr, routine, arg)               		\
-	_STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, 0)
-
-/*
- * Encapsulation of the starpu_pthread_mutex_* functions.
- */
-
-#define _STARPU_PTHREAD_MUTEX_INIT(mutex, attr) do {                           \
-	int p_ret = starpu_pthread_mutex_init((mutex), (attr));                \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_mutex_init: %s\n",               \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_MUTEX_DESTROY(mutex) do {                              \
-	int p_ret = starpu_pthread_mutex_destroy(mutex);                       \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_mutex_destroy: %s\n",            \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while(0)
-
-#define _STARPU_PTHREAD_MUTEX_LOCK(mutex) do {                                 \
-	int p_ret = starpu_pthread_mutex_lock(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_UNLOCK(mutex) do {                               \
-	int p_ret = starpu_pthread_mutex_unlock(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)
-
-int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex);
-
-/*
- * Encapsulation of the starpu_pthread_key_* functions.
- */
-#define _STARPU_PTHREAD_KEY_CREATE(key, destr) do {                            \
-	int p_ret = starpu_pthread_key_create((key), (destr));	               \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_key_create: %s\n",               \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_KEY_DELETE(key) do {                                   \
-	int p_ret = starpu_pthread_key_delete((key));	                       \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_key_delete: %s\n",               \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_SETSPECIFIC(key, ptr) do {                             \
-	int p_ret = starpu_pthread_setspecific((key), (ptr));	               \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_setspecific: %s\n",              \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-	};                                                                     \
-} while (0)
-
-#define _STARPU_PTHREAD_GETSPECIFIC(key) starpu_pthread_getspecific((key))
-
-/*
- * Encapsulation of the starpu_pthread_rwlock_* functions.
- */
-#define _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) do {                         \
-	int p_ret = starpu_pthread_rwlock_init((rwlock), (attr));              \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_rwlock_init: %s\n",              \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) do {                             \
-	int p_ret = starpu_pthread_rwlock_rdlock(rwlock);                      \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_rwlock_rdlock: %s\n",            \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) do {                             \
-	int p_ret = starpu_pthread_rwlock_wrlock(rwlock);                      \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_rwlock_wrlock: %s\n",            \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) do {                             \
-	int p_ret = starpu_pthread_rwlock_unlock(rwlock);                      \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_rwlock_unlock: %s\n",            \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) do {                            \
-	int p_ret = starpu_pthread_rwlock_destroy(rwlock);                     \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_rwlock_destroy: %s\n",           \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-/*
- * Encapsulation of the starpu_pthread_cond_* functions.
- */
-#define _STARPU_PTHREAD_COND_INIT(cond, attr) do {                             \
-	int p_ret = starpu_pthread_cond_init((cond), (attr));                  \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_cond_init: %s\n",                \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_COND_DESTROY(cond) do {                                \
-	int p_ret = starpu_pthread_cond_destroy(cond);                         \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_cond_destroy: %s\n",             \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-			STARPU_ABORT();                                        \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_COND_SIGNAL(cond) do {                                 \
-	int p_ret = starpu_pthread_cond_signal(cond);                          \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_cond_signal: %s\n",              \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_COND_BROADCAST(cond) do {                              \
-	int p_ret = starpu_pthread_cond_broadcast(cond);                       \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_cond_broadcast: %s\n",           \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_COND_WAIT(cond, mutex) do {                            \
-	int p_ret = starpu_pthread_cond_wait((cond), (mutex));                 \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d starpu_pthread_cond_wait: %s\n",                \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-/*
- * Encapsulation of the starpu_pthread_barrier_* functions.
- */
 #define _starpu_pthread_barrier_t pthread_barrier_t
 
-#define _STARPU_PTHREAD_BARRIER_INIT(barrier, attr, count) do {                \
-	int p_ret = pthread_barrier_init((barrier), (attr), (count));          \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d pthread_barrier_init: %s\n",                    \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_BARRIER_DESTROY(barrier) do {                          \
-	int p_ret = pthread_barrier_destroy((barrier));                        \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
-		fprintf(stderr,                                                \
-			"%s:%d pthread_barrier_destroy: %s\n",                 \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
-	}                                                                      \
-} while (0)
-
-#define _STARPU_PTHREAD_BARRIER_WAIT(barrier) do {                             \
-	int p_ret = pthread_barrier_wait(barrier);                             \
-	if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == PTHREAD_BARRIER_SERIAL_THREAD)))) { \
-		fprintf(stderr,                                                \
-			"%s:%d pthread_barrier_wait: %s\n",                    \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-			STARPU_ABORT();                                        \
-	}                                                                      \
-} while (0)
-
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 typedef pthread_spinlock_t _starpu_pthread_spinlock_t;
 #endif

src/common/utils.c

@@ -109,7 +109,7 @@ int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex)
 	ret = starpu_pthread_mutex_trylock(mutex);
 	if (!ret)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(mutex);
 		return 0;
 	}
 

src/common/utils.h

@@ -117,4 +117,6 @@ struct starpu_codelet;
 /* Returns the symbol associated to that job if any. */
 const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 
+int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex);
+
 #endif // __COMMON_UTILS_H__

src/core/debug.c

@@ -61,9 +61,9 @@ void _starpu_print_to_logfile(const char *format STARPU_ATTRIBUTE_UNUSED, ...)
 #ifdef STARPU_VERBOSE
 	va_list args;
 	va_start(args, format);
-	_STARPU_PTHREAD_MUTEX_LOCK(&logfile_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&logfile_mutex);
 	vfprintf(logfile, format, args);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&logfile_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&logfile_mutex);
 	va_end( args );
 #endif
 }
@@ -84,14 +84,14 @@ int64_t _starpu_ayudame_get_func_id(struct starpu_codelet *cl)
 	if (!cl)
 		return -1;
 	name = _starpu_codelet_get_model_name(cl);
-	_STARPU_PTHREAD_MUTEX_LOCK(&ayudame_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&ayudame_mutex);
 	for (i=0; i < ncodelets; i++)
 	{
 		if (codelets[i].cl == cl &&
 			((!name && !codelets[i].name) ||
 				((name && codelets[i].name) && !strcmp(codelets[i].name, name))))
 		{
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&ayudame_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&ayudame_mutex);
 			return i;
 		}
 	}
@@ -112,7 +112,7 @@ int64_t _starpu_ayudame_get_func_id(struct starpu_codelet *cl)
 	i = ncodelets++;
 	if (name)
 		AYU_event(AYU_REGISTERFUNCTION, i, (void*) name);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&ayudame_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&ayudame_mutex);
 	return i;
 }
 #endif

src/core/dependencies/cg.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2012  Université de Bordeaux 1
- * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
  * Copyright (C) 2012 inria
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -115,10 +115,10 @@ void _starpu_notify_cg(struct _starpu_cg *cg)
 			{
 				/* this is a cg for an application waiting on a set of
 				 * tags, wake the thread */
-				_STARPU_PTHREAD_MUTEX_LOCK(&cg->succ.succ_apps.cg_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&cg->succ.succ_apps.cg_mutex);
 				cg->succ.succ_apps.completed = 1;
-				_STARPU_PTHREAD_COND_SIGNAL(&cg->succ.succ_apps.cg_cond);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
+				STARPU_PTHREAD_COND_SIGNAL(&cg->succ.succ_apps.cg_cond);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
 				break;
 			}
 
@@ -145,7 +145,7 @@ void _starpu_notify_cg(struct _starpu_cg *cg)
 			{
 				j = cg->succ.job;
 
-				_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 
 				job_successors = &j->job_successors;
 
@@ -164,7 +164,7 @@ void _starpu_notify_cg(struct _starpu_cg *cg)
 					 * do not do them again since the tag has been cleared! */
 					_starpu_enforce_deps_starting_from_task(j);
 				} else
-					_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 
 				break;

src/core/dependencies/implicit_data_deps.c

@@ -344,9 +344,9 @@ void _starpu_detect_implicit_data_deps(struct starpu_task *task)
 		if (mode & STARPU_SCRATCH)
 			continue;
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 		new_task = _starpu_detect_implicit_data_deps_with_handle(task, task, handle, mode);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 		if (new_task)
 		{
 			int ret = _starpu_task_submit_internally(new_task);
@@ -367,7 +367,7 @@ void _starpu_detect_implicit_data_deps(struct starpu_task *task)
 /* the sequential_consistency_mutex of the handle has to be already held */
 void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *task, starpu_data_handle_t handle)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 
 	if (handle->sequential_consistency)
 	{
@@ -449,7 +449,7 @@ void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *tas
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 }
 
 /* This is the same as _starpu_release_data_enforce_sequential_consistency, but
@@ -490,7 +490,7 @@ void _starpu_release_task_enforce_sequential_consistency(struct _starpu_job *j)
 void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data_handle_t handle)
 {
         _STARPU_LOG_IN();
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 
 	if (handle->sequential_consistency)
 	{
@@ -502,7 +502,7 @@ void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data
 		handle->post_sync_tasks = link;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
         _STARPU_LOG_OUT();
 }
 
@@ -511,7 +511,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 	struct _starpu_task_wrapper_list *post_sync_tasks = NULL;
 	unsigned do_submit_tasks = 0;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 
 	if (handle->sequential_consistency)
 	{
@@ -526,7 +526,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 	if (do_submit_tasks)
 	{
@@ -551,7 +551,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_access_mode mode)
 {
 	/* If sequential consistency is enabled, wait until data is available */
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 	int sequential_consistency = handle->sequential_consistency;
 	if (sequential_consistency)
 	{
@@ -566,7 +566,7 @@ int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_a
 		/* It is not really a RW access, but we want to make sure that
 		 * all previous accesses are done */
 		new_task = _starpu_detect_implicit_data_deps_with_handle(sync_task, sync_task, handle, mode);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 		if (new_task)
 		{
@@ -582,7 +582,7 @@ int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_a
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 	}
 
 	return 0;

src/core/dependencies/tags.c

@@ -51,8 +51,8 @@ static struct _starpu_cg *create_cg_apps(unsigned ntags)
 	cg->cg_type = STARPU_CG_APPS;
 
 	cg->succ.succ_apps.completed = 0;
-	_STARPU_PTHREAD_MUTEX_INIT(&cg->succ.succ_apps.cg_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&cg->succ.succ_apps.cg_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&cg->succ.succ_apps.cg_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&cg->succ.succ_apps.cg_cond, NULL);
 
 	return cg;
 }
@@ -132,7 +132,7 @@ static void _starpu_tag_free(void *_tag)
  */
 void _starpu_init_tags(void)
 {
-	_STARPU_PTHREAD_RWLOCK_INIT(&tag_global_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_INIT(&tag_global_rwlock, NULL);
 }
 
 void starpu_tag_remove(starpu_tag_t id)
@@ -144,12 +144,12 @@ void starpu_tag_remove(starpu_tag_t id)
 		AYU_event(AYU_REMOVETASK, id + AYUDAME_OFFSET, NULL);
 #endif
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
 
 	HASH_FIND_UINT64_T(tag_htbl, &id, entry);
 	if (entry) HASH_DEL(tag_htbl, entry);
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
 
 	if (entry)
 	{
@@ -160,7 +160,7 @@ void starpu_tag_remove(starpu_tag_t id)
 
 void _starpu_tag_clear(void)
 {
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
 
 	/* XXX: _starpu_tag_free takes the tag spinlocks while we are keeping
 	 * the global rwlock. This contradicts the lock order of
@@ -175,7 +175,7 @@ void _starpu_tag_clear(void)
 		free(entry);
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
 }
 
 static struct _starpu_tag *_gettag_struct(starpu_tag_t id)
@@ -216,9 +216,9 @@ static struct _starpu_tag *_gettag_struct(starpu_tag_t id)
 static struct _starpu_tag *gettag_struct(starpu_tag_t id)
 {
 	struct _starpu_tag *tag;
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
 	tag = _gettag_struct(id);
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
 	return tag;
 }
 
@@ -237,7 +237,7 @@ void _starpu_tag_set_ready(struct _starpu_tag *tag)
 	_starpu_spin_unlock(&tag->lock);
 
 	/* enforce data dependencies */
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 	_starpu_enforce_deps_starting_from_task(j);
 
 	_starpu_spin_lock(&tag->lock);
@@ -437,7 +437,7 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 		return -EDEADLK;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&tag_global_rwlock);
 	/* only wait the tags that are not done yet */
 	for (i = 0, current = 0; i < ntags; i++)
 	{
@@ -456,7 +456,7 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 			current++;
 		}
 	}
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&tag_global_rwlock);
 
 	if (current == 0)
 	{
@@ -474,15 +474,15 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 		_starpu_spin_unlock(&tag_array[i]->lock);
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&cg->succ.succ_apps.cg_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cg->succ.succ_apps.cg_mutex);
 
 	while (!cg->succ.succ_apps.completed)
-		_STARPU_PTHREAD_COND_WAIT(&cg->succ.succ_apps.cg_cond, &cg->succ.succ_apps.cg_mutex);
+		STARPU_PTHREAD_COND_WAIT(&cg->succ.succ_apps.cg_cond, &cg->succ.succ_apps.cg_mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
 
-	_STARPU_PTHREAD_MUTEX_DESTROY(&cg->succ.succ_apps.cg_mutex);
-	_STARPU_PTHREAD_COND_DESTROY(&cg->succ.succ_apps.cg_cond);
+	STARPU_PTHREAD_MUTEX_DESTROY(&cg->succ.succ_apps.cg_mutex);
+	STARPU_PTHREAD_COND_DESTROY(&cg->succ.succ_apps.cg_cond);
 
 	free(cg);
 

src/core/jobs.c

@@ -78,8 +78,8 @@ struct _starpu_job* __attribute__((malloc)) _starpu_job_create(struct starpu_tas
 
 	_starpu_cg_list_init(&job->job_successors);
 
-	_STARPU_PTHREAD_MUTEX_INIT(&job->sync_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&job->sync_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&job->sync_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&job->sync_cond, NULL);
 
 	/* By default we have sequential tasks */
 	job->task_size = 1;
@@ -95,15 +95,15 @@ void _starpu_job_destroy(struct _starpu_job *j)
 {
 	/* Wait for any code that was still working on the job (and was
 	 * probably our waker) */
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
-	_STARPU_PTHREAD_COND_DESTROY(&j->sync_cond);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_COND_DESTROY(&j->sync_cond);
+	STARPU_PTHREAD_MUTEX_DESTROY(&j->sync_mutex);
 
 	if (j->task_size > 1)
 	{
-		_STARPU_PTHREAD_BARRIER_DESTROY(&j->before_work_barrier);
-		_STARPU_PTHREAD_BARRIER_DESTROY(&j->after_work_barrier);
+		STARPU_PTHREAD_BARRIER_DESTROY(&j->before_work_barrier);
+		STARPU_PTHREAD_BARRIER_DESTROY(&j->after_work_barrier);
 	}
 
 	_starpu_cg_list_deinit(&j->job_successors);
@@ -122,7 +122,7 @@ void _starpu_wait_job(struct _starpu_job *j)
 	STARPU_ASSERT(!j->task->detach);
         _STARPU_LOG_IN();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 
 	/* We wait for the flag to have a value of 2 which means that both the
 	 * codelet's implementation and its callback have been executed. That
@@ -130,9 +130,9 @@ void _starpu_wait_job(struct _starpu_job *j)
 	 * executed (so that we cannot destroy the task while it is still being
 	 * manipulated by the driver). */
 	while (j->terminated != 2)
-		_STARPU_PTHREAD_COND_WAIT(&j->sync_cond, &j->sync_mutex);
+		STARPU_PTHREAD_COND_WAIT(&j->sync_cond, &j->sync_mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
         _STARPU_LOG_OUT();
 }
 
@@ -140,7 +140,7 @@ void _starpu_handle_job_termination(struct _starpu_job *j)
 {
 	struct starpu_task *task = j->task;
 	unsigned sched_ctx = task->sched_ctx;
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 
 	task->status = STARPU_TASK_FINISHED;
 
@@ -150,7 +150,7 @@ void _starpu_handle_job_termination(struct _starpu_job *j)
 	 * the callback is not done yet. */
 	j->terminated = 1;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 #ifdef STARPU_USE_SC_HYPERVISOR
 	int workerid = starpu_worker_get_id();
@@ -252,17 +252,17 @@ void _starpu_handle_job_termination(struct _starpu_job *j)
 
 	/* we do not desallocate the job structure if some is going to
 	 * wait after the task */
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 	/* A value of 2 is put to specify that not only the codelet but
 	 * also the callback were executed. */
 	j->terminated = 2;
-	_STARPU_PTHREAD_COND_BROADCAST(&j->sync_cond);
+	STARPU_PTHREAD_COND_BROADCAST(&j->sync_cond);
 
 #ifdef HAVE_AYUDAME_H
 	if (AYU_event) AYU_event(AYU_REMOVETASK, j->job_id, NULL);
 #endif
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 	if (detach)
 	{
@@ -375,7 +375,7 @@ unsigned _starpu_enforce_deps_and_schedule(struct _starpu_job *j)
 	/* enfore tag dependencies */
 	if (_starpu_not_all_tag_deps_are_fulfilled(j))
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 		_STARPU_LOG_OUT_TAG("not_all_tag_deps_are_fulfilled");
 		return 0;
 	}
@@ -383,11 +383,11 @@ unsigned _starpu_enforce_deps_and_schedule(struct _starpu_job *j)
 	/* enfore task dependencies */
 	if (_starpu_not_all_task_deps_are_fulfilled(j))
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 		_STARPU_LOG_OUT_TAG("not_all_task_deps_are_fulfilled");
 		return 0;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 	/* enforce data dependencies */
 	if (_starpu_submit_job_enforce_data_deps(j))
@@ -410,10 +410,10 @@ unsigned _starpu_enforce_deps_starting_from_task(struct _starpu_job *j)
 	/* enfore task dependencies */
 	if (_starpu_not_all_task_deps_are_fulfilled(j))
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 		return 0;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 	/* enforce data dependencies */
 	if (_starpu_submit_job_enforce_data_deps(j))
@@ -442,16 +442,16 @@ 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_COND_BROADCAST(&worker->sched_cond);
 	starpu_push_task_end(task);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 
 	return 0;
 }

src/core/parallel_task.c

@@ -48,8 +48,8 @@ void starpu_parallel_task_barrier_init(struct starpu_task* task, int workerid)
 
 	//fprintf(stderr, "POP -> size %d best_size %d\n", worker_size, best_size);
 
-	_STARPU_PTHREAD_BARRIER_INIT(&j->before_work_barrier, NULL, worker_size);
-	_STARPU_PTHREAD_BARRIER_INIT(&j->after_work_barrier, NULL, worker_size);
+	STARPU_PTHREAD_BARRIER_INIT(&j->before_work_barrier, NULL, worker_size);
+	STARPU_PTHREAD_BARRIER_INIT(&j->after_work_barrier, NULL, worker_size);
 
 	return;
 }

src/core/perfmodel/perfmodel.c

@@ -302,7 +302,7 @@ double starpu_task_bundle_expected_length(starpu_task_bundle_t bundle, enum star
 	double expected_length = 0.0;
 
 	/* We expect the length of the bundle the be the sum of the different tasks length. */
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	struct _starpu_task_bundle_entry *entry;
 	entry = bundle->list;
@@ -312,17 +312,17 @@ double starpu_task_bundle_expected_length(starpu_task_bundle_t bundle, enum star
 		if(!entry->task->scheduled)
 		{
 			double task_length = starpu_task_expected_length(entry->task, arch, nimpl);
-			
+
 			/* In case the task is not calibrated, we consider the task
 			 * ends immediately. */
 			if (task_length > 0.0)
 				expected_length += task_length;
 		}
-			
+
 		entry = entry->next;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 
 	return expected_length;
 }
@@ -333,7 +333,7 @@ double starpu_task_bundle_expected_power(starpu_task_bundle_t bundle, enum starp
 	double expected_power = 0.0;
 
 	/* We expect total consumption of the bundle the be the sum of the different tasks consumption. */
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	struct _starpu_task_bundle_entry *entry;
 	entry = bundle->list;
@@ -350,7 +350,7 @@ double starpu_task_bundle_expected_power(starpu_task_bundle_t bundle, enum starp
 		entry = entry->next;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 
 	return expected_power;
 }
@@ -358,7 +358,7 @@ double starpu_task_bundle_expected_power(starpu_task_bundle_t bundle, enum starp
 /* Return the time (in µs) expected to transfer all data used within the bundle */
 double starpu_task_bundle_expected_data_transfer_time(starpu_task_bundle_t bundle, unsigned memory_node)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	struct _starpu_handle_list *handles = NULL;
 
@@ -390,7 +390,7 @@ double starpu_task_bundle_expected_data_transfer_time(starpu_task_bundle_t bundl
 		entry = entry->next;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 
 	/* Compute the sum of data transfer time, and destroy the list */
 

src/core/perfmodel/perfmodel_history.c

@@ -593,20 +593,20 @@ static void get_model_debug_path(struct starpu_perfmodel *model, const char *arc
 int _starpu_register_model(struct starpu_perfmodel *model)
 {
 	/* If the model has already been loaded, there is nothing to do */
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
 	if (model->is_loaded)
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 		return 0;
 	}
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 
 	/* We have to make sure the model has not been loaded since the
          * last time we took the lock */
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 	if (model->is_loaded)
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 		return 0;
 	}
 
@@ -635,7 +635,7 @@ int _starpu_register_model(struct starpu_perfmodel *model)
 	}
 #endif
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 	return 1;
 }
 
@@ -675,7 +675,7 @@ static void save_history_based_model(struct starpu_perfmodel *model)
 
 static void _starpu_dump_registered_models(void)
 {
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
 	struct _starpu_perfmodel_list *node;
 	node = registered_models;
@@ -688,14 +688,14 @@ static void _starpu_dump_registered_models(void)
 		node = node->next;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 }
 
 void _starpu_initialize_registered_performance_models(void)
 {
 	registered_models = NULL;
 
-	_STARPU_PTHREAD_RWLOCK_INIT(&registered_models_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_INIT(&registered_models_rwlock, NULL);
 }
 
 void _starpu_deinitialize_performance_model(struct starpu_perfmodel *model)
@@ -738,7 +738,7 @@ void _starpu_deinitialize_registered_performance_models(void)
 	if (_starpu_get_calibrate_flag())
 		_starpu_dump_registered_models();
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
 	struct _starpu_perfmodel_list *node, *pnode;
 	node = registered_models;
@@ -749,9 +749,9 @@ void _starpu_deinitialize_registered_performance_models(void)
 	{
 		struct starpu_perfmodel *model = node->model;
 
-		_STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
 		_starpu_deinitialize_performance_model(model);
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
 		pnode = node;
 		node = node->next;
@@ -759,8 +759,8 @@ void _starpu_deinitialize_registered_performance_models(void)
 	}
 	registered_models = NULL;
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
-	_STARPU_PTHREAD_RWLOCK_DESTROY(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_DESTROY(&registered_models_rwlock);
 }
 
 /*
@@ -774,26 +774,26 @@ void _starpu_load_per_arch_based_model(struct starpu_perfmodel *model)
 
 	int already_loaded;
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
 	already_loaded = model->is_loaded;
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 
 	if (already_loaded)
 		return;
 
 	/* The model is still not loaded so we grab the lock in write mode, and
 	 * if it's not loaded once we have the lock, we do load it. */
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
 	/* Was the model initialized since the previous test ? */
 	if (model->is_loaded)
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 		return;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 }
 
 void _starpu_load_common_based_model(struct starpu_perfmodel *model)
@@ -802,26 +802,26 @@ void _starpu_load_common_based_model(struct starpu_perfmodel *model)
 
 	int already_loaded;
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
 	already_loaded = model->is_loaded;
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 
 	if (already_loaded)
 		return;
 
 	/* The model is still not loaded so we grab the lock in write mode, and
 	 * if it's not loaded once we have the lock, we do load it. */
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
 	/* Was the model initialized since the previous test ? */
 	if (model->is_loaded)
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 		return;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 }
 
 /* We first try to grab the global lock in read mode to check whether the model
@@ -835,9 +835,9 @@ void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned s
 
 	int already_loaded;
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
 	already_loaded = model->is_loaded;
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 
 	if (already_loaded)
 		return;
@@ -845,18 +845,18 @@ void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned s
 	/* The model is still not loaded so we grab the lock in write mode, and
 	 * if it's not loaded once we have the lock, we do load it. */
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
 	/* Was the model initialized since the previous test ? */
 	if (model->is_loaded)
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 		return;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
 
 	/* make sure the performance model directory exists (or create it) */
 	_starpu_create_sampling_directory_if_needed();
@@ -911,9 +911,9 @@ void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned s
 
 	model->is_loaded = 1;
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&registered_models_rwlock);
 }
 
 /* This function is intended to be used by external tools that should read
@@ -1072,10 +1072,10 @@ double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfm
 		struct starpu_perfmodel_history_table *history;
 		struct starpu_perfmodel_history_table *entry;
 
-		_STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
 		history = per_arch_model->history;
 		HASH_FIND_UINT32_T(history, &key, entry);
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
 		/* We do not care about racing access to the mean, we only want a
 		 * good-enough estimation, thus simulate taking the rdlock */
@@ -1109,11 +1109,11 @@ double _starpu_history_based_job_expected_perf(struct starpu_perfmodel *model, e
 
 	per_arch_model = &model->per_arch[arch][nimpl];
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
 	history = per_arch_model->history;
 	HASH_FIND_UINT32_T(history, &key, elt);
 	entry = (elt == NULL) ? NULL : elt->history_entry;
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
 	/* We do not care about racing access to the mean, we only want a
 	 * good-enough estimation, thus simulate taking the rdlock */
@@ -1156,7 +1156,7 @@ void _starpu_update_perfmodel_history(struct _starpu_job *j, struct starpu_perfm
 {
 	if (model)
 	{
-		_STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
 
 		struct starpu_perfmodel_per_arch *per_arch_model = &model->per_arch[arch][nimpl];
 
@@ -1276,7 +1276,7 @@ void _starpu_update_perfmodel_history(struct _starpu_job *j, struct starpu_perfm
 		fprintf(f, "\n");
 		fclose(f);
 #endif
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 	}
 }
 

src/core/progress_hook.c

@@ -40,13 +40,13 @@ static int active_hook_cnt = 0;
  */
 void _starpu_init_progression_hooks(void)
 {
-	_STARPU_PTHREAD_RWLOCK_INIT(&progression_hook_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_INIT(&progression_hook_rwlock, NULL);
 }
 
 int starpu_progression_hook_register(unsigned (*func)(void *arg), void *arg)
 {
 	int hook;
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&progression_hook_rwlock);
 	for (hook = 0; hook < NMAXHOOKS; hook++)
 	{
 		if (!hooks[hook].active)
@@ -57,13 +57,13 @@ int starpu_progression_hook_register(unsigned (*func)(void *arg), void *arg)
 			hooks[hook].active = 1;
 			active_hook_cnt++;
 
-			_STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
+			STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
 
 			return hook;
 		}
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
 
 	starpu_wake_all_blocked_workers();
 
@@ -73,22 +73,22 @@ int starpu_progression_hook_register(unsigned (*func)(void *arg), void *arg)
 
 void starpu_progression_hook_deregister(int hook_id)
 {
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&progression_hook_rwlock);
 
 	if (hooks[hook_id].active)
 		active_hook_cnt--;
 
 	hooks[hook_id].active = 0;
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
 }
 
 unsigned _starpu_execute_registered_progression_hooks(void)
 {
 	/* If there is no hook registered, we short-cut loop. */
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&progression_hook_rwlock);
 	int no_hook = (active_hook_cnt == 0);
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
 
 	if (no_hook)
 		return 1;
@@ -102,9 +102,9 @@ unsigned _starpu_execute_registered_progression_hooks(void)
 	{
 		unsigned active;
 
-		_STARPU_PTHREAD_RWLOCK_RDLOCK(&progression_hook_rwlock);
+		STARPU_PTHREAD_RWLOCK_RDLOCK(&progression_hook_rwlock);
 		active = hooks[hook].active;
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&progression_hook_rwlock);
 
 		unsigned may_block_hook = 1;
 

src/core/sched_ctx.c

@@ -80,9 +80,9 @@ static void _starpu_update_workers_with_ctx(int *workerids, int nworkers, int sc
 			_starpu_worker_gets_into_ctx(sched_ctx_id, worker);
 		else
 		{
-			_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
 			_starpu_worker_gets_into_ctx(sched_ctx_id, worker);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 		}
 	}
 
@@ -104,9 +104,9 @@ static void _starpu_update_workers_without_ctx(int *workerids, int nworkers, int
 				_starpu_worker_gets_out_of_ctx(sched_ctx_id, worker);
 			else
 			{
-					_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+					STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
 					_starpu_worker_gets_out_of_ctx(sched_ctx_id, worker);
-					_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 			}
 		}
 		else
@@ -115,9 +115,9 @@ static void _starpu_update_workers_without_ctx(int *workerids, int nworkers, int
 				worker->removed_from_ctx[sched_ctx_id] = 1;
 			else
 			{
-				_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
 				worker->removed_from_ctx[sched_ctx_id] = 1;
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
 			}
 		}
 	}
@@ -152,9 +152,9 @@ static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx
 			else
 			{
 				struct _starpu_worker *worker_str = _starpu_get_worker_struct(workerids[i]);
-				_STARPU_PTHREAD_MUTEX_LOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&worker_str->sched_mutex);
 				worker_str->removed_from_ctx[sched_ctx->id] = 0;
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_str->sched_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&worker_str->sched_mutex);
 			}
 		}
 		else
@@ -221,7 +221,7 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 {
 	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
 	STARPU_ASSERT(config->topology.nsched_ctxs < STARPU_NMAX_SCHED_CTXS);
 
 	unsigned id = _starpu_get_first_free_sched_ctx(config);
@@ -230,13 +230,13 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 	sched_ctx->id = id;
 
 	config->topology.nsched_ctxs++;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
 
 	int nworkers = config->topology.nworkers;
 
 	STARPU_ASSERT(nworkers_ctx <= nworkers);
 
-	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->empty_ctx_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->empty_ctx_mutex, NULL);
 
 	starpu_task_list_init(&sched_ctx->empty_ctx_tasks);
 
@@ -267,7 +267,7 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 		int i;
 		/*initialize the mutexes for all contexts */
 		for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
-			_STARPU_PTHREAD_MUTEX_INIT(&changing_ctx_mutex[i], NULL);
+			STARPU_PTHREAD_MUTEX_INIT(&changing_ctx_mutex[i], NULL);
 		for(i = 0; i < nworkers; i++)
 		{
 			struct _starpu_worker *worker = _starpu_get_worker_struct(i);
@@ -408,10 +408,10 @@ unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const
 	struct _starpu_sched_ctx *sched_ctx = NULL;
 	int workers[max_ncpus + max_ngpus];
 	int nw = 0;
-	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
 	_get_workers(min_ncpus, max_ncpus, workers, &nw, STARPU_CPU_WORKER, allow_overlap);
 	_get_workers(min_ngpus, max_ngpus, workers, &nw, STARPU_CUDA_WORKER, allow_overlap);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
 	int i;
 	printf("%d: ", nw);
 	for(i = 0; i < nw; i++)
@@ -460,13 +460,13 @@ static void _starpu_delete_sched_ctx(struct _starpu_sched_ctx *sched_ctx)
 	free(sched_ctx->sched_policy);
 	sched_ctx->sched_policy = NULL;
 
-	_STARPU_PTHREAD_MUTEX_DESTROY(&sched_ctx->empty_ctx_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&sched_ctx->empty_ctx_mutex);
 	sched_ctx->id = STARPU_NMAX_SCHED_CTXS;
 
 	struct _starpu_machine_config *config = _starpu_get_machine_config();
-	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx_manag);
 	config->topology.nsched_ctxs--;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
 }
 
 void starpu_sched_ctx_delete(unsigned sched_ctx_id)
@@ -481,7 +481,7 @@ void starpu_sched_ctx_delete(unsigned sched_ctx_id)
 	unsigned inheritor_sched_ctx_id = sched_ctx->inheritor;
 	struct _starpu_sched_ctx *inheritor_sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx->inheritor);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
 	STARPU_ASSERT(sched_ctx->id != STARPU_NMAX_SCHED_CTXS);
 
 	int *workerids;
@@ -511,7 +511,7 @@ void starpu_sched_ctx_delete(unsigned sched_ctx_id)
 	/* workerids is malloc-ed in _get_workers_list, don't forget to free it when
 	   you don't use it anymore */
 	free(workerids);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
 	return;
 }
 
@@ -522,16 +522,16 @@ void _starpu_delete_all_sched_ctxs()
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
 	{
 		struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(i);
-		_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[i]);
+		STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[i]);
 		if(sched_ctx->id != STARPU_NMAX_SCHED_CTXS)
 		{
 			_starpu_sched_ctx_free_scheduling_data(sched_ctx);
 			_starpu_barrier_counter_destroy(&sched_ctx->tasks_barrier);
 			_starpu_delete_sched_ctx(sched_ctx);
 		}
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[i]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[i]);
 
-		_STARPU_PTHREAD_MUTEX_DESTROY(&changing_ctx_mutex[i]);
+		STARPU_PTHREAD_MUTEX_DESTROY(&changing_ctx_mutex[i]);
 	}
 	return;
 }
@@ -552,25 +552,25 @@ static void _starpu_check_workers(int *workerids, int nworkers)
 void _starpu_fetch_tasks_from_empty_ctx_list(struct _starpu_sched_ctx *sched_ctx)
 {
 	unsigned unlocked = 0;
-	_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
 
 	if(starpu_task_list_empty(&sched_ctx->empty_ctx_tasks))
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 		return;
 	}
 	else
                 /* you're not suppose to get here if you deleted the context
 		   so no point in having the mutex locked */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx->id]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx->id]);
 	
 	while(!starpu_task_list_empty(&sched_ctx->empty_ctx_tasks))
 	{
 		if(unlocked)
-			_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
 		struct starpu_task *old_task = starpu_task_list_pop_back(&sched_ctx->empty_ctx_tasks);
 		unlocked = 1;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 
 		if(old_task == &stop_submission_task)
 			break;
@@ -580,11 +580,11 @@ void _starpu_fetch_tasks_from_empty_ctx_list(struct _starpu_sched_ctx *sched_ctx
 		if(ret == -EAGAIN) break;
 	}
 	if(!unlocked)
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 
 
 	/* leave the mutex as it was to avoid pbs in the caller function */
-	_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx->id]);
+	STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx->id]);
 	return;
 
 }
@@ -594,7 +594,7 @@ void starpu_sched_ctx_add_workers(int *workers_to_add, int nworkers_to_add, unsi
 	int added_workers[nworkers_to_add];
 	int n_added_workers = 0;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
 
 	STARPU_ASSERT(workers_to_add != NULL && nworkers_to_add > 0);
 	_starpu_check_workers(workers_to_add, nworkers_to_add);
@@ -612,7 +612,7 @@ void starpu_sched_ctx_add_workers(int *workers_to_add, int nworkers_to_add, unsi
 		_starpu_fetch_tasks_from_empty_ctx_list(sched_ctx);
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
 
 
 	return;
@@ -626,7 +626,7 @@ void starpu_sched_ctx_remove_workers(int *workers_to_remove, int nworkers_to_rem
 
 	_starpu_check_workers(workers_to_remove, nworkers_to_remove);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
 	/* if the context has not already been deleted */
 	if(sched_ctx->id != STARPU_NMAX_SCHED_CTXS)
 	{
@@ -636,7 +636,7 @@ void starpu_sched_ctx_remove_workers(int *workers_to_remove, int nworkers_to_rem
 			_starpu_update_workers_without_ctx(removed_workers, n_removed_workers, sched_ctx->id, 0);
 
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
 	return;
 }
 
@@ -734,13 +734,13 @@ void _starpu_decrement_nsubmitted_tasks_of_sched_ctx(unsigned sched_ctx_id)
   we can move all its workers to the inheritor context */
 	if(finished && sched_ctx->inheritor != STARPU_NMAX_SCHED_CTXS)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&finished_submit_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&finished_submit_mutex);
 		if(sched_ctx->finished_submit)
 		{
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
 
 			/* take care the context is not deleted or changed at the same time */
-			_STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
+			STARPU_PTHREAD_MUTEX_LOCK(&changing_ctx_mutex[sched_ctx_id]);
 			if(sched_ctx->id != STARPU_NMAX_SCHED_CTXS)
 			{
 				int *workerids = NULL;
@@ -752,11 +752,11 @@ void _starpu_decrement_nsubmitted_tasks_of_sched_ctx(unsigned sched_ctx_id)
 					free(workerids);
 				}
 			}
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&changing_ctx_mutex[sched_ctx_id]);
 
 			return;
 		}
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
 	}
 	return;
 }
@@ -1031,9 +1031,9 @@ void starpu_sched_ctx_set_inheritor(unsigned sched_ctx_id, unsigned inheritor)
 void starpu_sched_ctx_finished_submit(unsigned sched_ctx_id)
 {
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	_STARPU_PTHREAD_MUTEX_LOCK(&finished_submit_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&finished_submit_mutex);
 	sched_ctx->finished_submit = 1;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&finished_submit_mutex);
 	return;
 }
 

src/core/sched_policy.c

@@ -273,8 +273,8 @@ static int _starpu_push_task_on_specific_worker(struct starpu_task *task, int wo
 		job->combined_workerid = workerid;
 		job->active_task_alias_count = 0;
 
-		_STARPU_PTHREAD_BARRIER_INIT(&job->before_work_barrier, NULL, worker_size);
-		_STARPU_PTHREAD_BARRIER_INIT(&job->after_work_barrier, NULL, worker_size);
+		STARPU_PTHREAD_BARRIER_INIT(&job->before_work_barrier, NULL, worker_size);
+		STARPU_PTHREAD_BARRIER_INIT(&job->after_work_barrier, NULL, worker_size);
 
 		/* Note: we have to call that early, or else the task may have
 		 * disappeared already */
@@ -342,9 +342,9 @@ int _starpu_push_task(struct _starpu_job *j)
 
 		if(nworkers == 0)
 		{
-			_STARPU_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);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 			return 0;
 		}
 	}
@@ -381,9 +381,9 @@ int _starpu_push_task_to_workers(struct starpu_task *task)
 
 		if (nworkers == 0)
 		{
-			_STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
 			starpu_task_list_push_back(&sched_ctx->empty_ctx_tasks, task);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
 			return -EAGAIN;
 		}
 	}
@@ -400,10 +400,10 @@ int _starpu_push_task_to_workers(struct starpu_task *task)
 		STARPU_ASSERT(sched_ctx->sched_policy->push_task);
 		/* check out if there are any workers in the context */
 		starpu_pthread_mutex_t *changing_ctx_mutex = _starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx->id);
-		_STARPU_PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(changing_ctx_mutex);
 		nworkers = starpu_sched_ctx_get_nworkers(sched_ctx->id);
 		ret = nworkers == 0 ? -1 : sched_ctx->sched_policy->push_task(task);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(changing_ctx_mutex);
 
 		if(ret == -1)
 		{
@@ -738,19 +738,19 @@ 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);
 
 	if (_starpu_machine_is_running())
 	{
 #ifndef STARPU_NON_BLOCKING_DRIVERS
-		_STARPU_PTHREAD_COND_WAIT(&worker->sched_cond,
+		STARPU_PTHREAD_COND_WAIT(&worker->sched_cond,
 					  &worker->sched_mutex);
 #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/simgrid.c

@@ -209,10 +209,10 @@ static int transfer_execute(int argc STARPU_ATTRIBUTE_UNUSED, char *argv[] STARP
 	MSG_task_execute(transfer->task);
 	MSG_task_destroy(transfer->task);
 	_STARPU_DEBUG("transfer %p finished\n", transfer);
-	_STARPU_PTHREAD_MUTEX_LOCK(transfer->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(transfer->mutex);
 	*transfer->finished = 1;
-	_STARPU_PTHREAD_COND_BROADCAST(transfer->cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(transfer->mutex);
+	STARPU_PTHREAD_COND_BROADCAST(transfer->cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(transfer->mutex);
 
 	/* The workers which started this request may be sleeping out of tasks, wake it  */
 	_starpu_wake_all_blocked_workers_on_node(transfer->run_node);
@@ -314,8 +314,8 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 	}
 
 	*transfer->finished = 0;
-	_STARPU_PTHREAD_MUTEX_INIT(transfer->mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(transfer->cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(transfer->mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(transfer->cond, NULL);
 	transfer->wake = NULL;
 	transfer->nwake = 0;
 	transfer->nwait = 0;
@@ -335,10 +335,10 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 	else
 	{
 		/* this is not associated to a request so it's synchronous */
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		while (!finished)
-			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+			STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return 0;
 	}
 }
@@ -346,7 +346,7 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 int
 _starpu_simgrid_thread_start(int argc STARPU_ATTRIBUTE_UNUSED, char *argv[] STARPU_ATTRIBUTE_UNUSED)
 {
-	struct _starpu_pthread_args *args = MSG_process_get_data(MSG_process_self());
+	struct starpu_pthread_args *args = MSG_process_get_data(MSG_process_self());
 	args->f(args->arg);
 	free(args);
 	return 0;

src/core/task.c

@@ -249,7 +249,7 @@ int _starpu_submit_job(struct _starpu_job *j)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 
 	/* Need to atomically set submitted to 1 and check dependencies, since
 	 * this is concucrent with _starpu_notify_cg */
@@ -456,7 +456,7 @@ int starpu_task_submit(struct starpu_task *task)
 		/* We need to make sure that models for other tasks of the
 		 * bundle are also loaded, so the scheduler can estimate the
 		 * duration of the whole bundle */
-		_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 		struct _starpu_task_bundle_entry *entry;
 		entry = bundle->list;
@@ -472,7 +472,7 @@ int starpu_task_submit(struct starpu_task *task)
 			entry = entry->next;
 		}
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 	}
 
 	/* If profiling is activated, we allocate a structure to store the
@@ -536,7 +536,7 @@ int _starpu_task_submit_nodeps(struct starpu_task *task)
 	struct _starpu_job *j = _starpu_get_job_associated_to_task(task);
 	_starpu_increment_nsubmitted_tasks();
 	_starpu_increment_nsubmitted_tasks_of_sched_ctx(j->task->sched_ctx);
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 
 	j->submitted = 1;
 
@@ -553,7 +553,7 @@ int _starpu_task_submit_nodeps(struct starpu_task *task)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 	return _starpu_push_task(j);
 }
@@ -590,7 +590,7 @@ int _starpu_task_submit_conversion_task(struct starpu_task *task,
 	struct _starpu_job *j = _starpu_get_job_associated_to_task(task);
 	_starpu_increment_nsubmitted_tasks();
 	_starpu_increment_nsubmitted_tasks_of_sched_ctx(j->task->sched_ctx);
-	_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 	j->submitted = 1;
 	_starpu_increment_nready_tasks();
 
@@ -618,7 +618,7 @@ int _starpu_task_submit_conversion_task(struct starpu_task *task,
 	_starpu_profiling_set_task_push_end_time(task);
 
         _STARPU_LOG_OUT();
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 	return 0;
 }
@@ -670,14 +670,14 @@ int starpu_task_wait_for_all(void)
 		if (STARPU_UNLIKELY(!_starpu_worker_may_perform_blocking_calls()))
 			return -EDEADLK;
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 		_STARPU_TRACE_TASK_WAIT_FOR_ALL;
 
 		while (nsubmitted > 0)
-			_STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
+			STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 
 #ifdef HAVE_AYUDAME_H
 		if (AYU_event) AYU_event(AYU_BARRIER, 0, NULL);
@@ -713,14 +713,14 @@ int starpu_task_wait_for_no_ready(void)
 	if (STARPU_UNLIKELY(!_starpu_worker_may_perform_blocking_calls()))
 		return -EDEADLK;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	_STARPU_TRACE_TASK_WAIT_FOR_ALL;
 
 	while (nready > 0)
-		_STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
+		STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 
 	return 0;
 }
@@ -729,7 +729,7 @@ void _starpu_decrement_nsubmitted_tasks(void)
 {
 	struct _starpu_machine_config *config = _starpu_get_machine_config();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	if (--nsubmitted == 0)
 	{
@@ -739,12 +739,12 @@ void _starpu_decrement_nsubmitted_tasks(void)
 			config->running = 0;
 			ANNOTATE_HAPPENS_BEFORE(&config->running);
 		}
-		_STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
+		STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
 	}
 
 	_STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 
 }
 
@@ -753,7 +753,7 @@ starpu_drivers_request_termination(void)
 {
 	struct _starpu_machine_config *config = _starpu_get_machine_config();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	config->submitting = 0;
 	if (nsubmitted == 0)
@@ -761,21 +761,21 @@ starpu_drivers_request_termination(void)
 		ANNOTATE_HAPPENS_AFTER(&config->running);
 		config->running = 0;
 		ANNOTATE_HAPPENS_BEFORE(&config->running);
-		_STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
+		STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 }
 
 static void _starpu_increment_nsubmitted_tasks(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	nsubmitted++;
 
 	_STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 }
 
 int starpu_task_nsubmitted(void)
@@ -785,21 +785,21 @@ int starpu_task_nsubmitted(void)
 
 void _starpu_increment_nready_tasks(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	nready++;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 }
 
 void _starpu_decrement_nready_tasks(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
 	if (--nready == 0)
-		_STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
+		STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 
 }
 
@@ -810,7 +810,7 @@ int starpu_task_nready(void)
 
 void _starpu_initialize_current_task_key(void)
 {
-	_STARPU_PTHREAD_KEY_CREATE(&current_task_key, NULL);
+	STARPU_PTHREAD_KEY_CREATE(&current_task_key, NULL);
 }
 
 /* Return the task currently executed by the worker, or NULL if this is called
@@ -818,12 +818,12 @@ void _starpu_initialize_current_task_key(void)
  * being executed at the moment. */
 struct starpu_task *starpu_task_get_current(void)
 {
-	return (struct starpu_task *) _STARPU_PTHREAD_GETSPECIFIC(current_task_key);
+	return (struct starpu_task *) STARPU_PTHREAD_GETSPECIFIC(current_task_key);
 }
 
 void _starpu_set_current_task(struct starpu_task *task)
 {
-	_STARPU_PTHREAD_SETSPECIFIC(current_task_key, task);
+	STARPU_PTHREAD_SETSPECIFIC(current_task_key, task);
 }
 
 /*
@@ -910,3 +910,13 @@ starpu_opencl_func_t _starpu_task_get_opencl_nth_implementation(struct starpu_co
 {
 	return cl->opencl_funcs[nimpl];
 }
+
+void starpu_task_set_implementation(struct starpu_task *task, unsigned impl)
+{
+	_starpu_get_job_associated_to_task(task)->nimpl = impl;
+}
+
+unsigned starpu_task_get_implementation(struct starpu_task *task)
+{
+	return _starpu_get_job_associated_to_task(task)->nimpl;
+}

src/core/task_bundle.c

@@ -31,7 +31,7 @@ void starpu_task_bundle_create(starpu_task_bundle_t *bundle)
 	*bundle = (starpu_task_bundle_t) malloc(sizeof(struct _starpu_task_bundle));
 	STARPU_ASSERT(*bundle);
 
-	_STARPU_PTHREAD_MUTEX_INIT(&(*bundle)->mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&(*bundle)->mutex, NULL);
 	/* Of course at the beginning a bundle is open,
 	 * user can insert and remove tasks from it */
 	(*bundle)->closed = 0;
@@ -43,12 +43,12 @@ void starpu_task_bundle_create(starpu_task_bundle_t *bundle)
 
 int starpu_task_bundle_insert(starpu_task_bundle_t bundle, struct starpu_task *task)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	if (bundle->closed)
 	{
 		/* The bundle is closed, we cannot add task anymore */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 		return -EPERM;
 	}
 
@@ -56,7 +56,7 @@ int starpu_task_bundle_insert(starpu_task_bundle_t bundle, struct starpu_task *t
 	{
 		/* The task has already been submitted, it's too late to put it
 		 * into a bundle now. */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 		return -EINVAL;
 	}
 
@@ -84,7 +84,7 @@ int starpu_task_bundle_insert(starpu_task_bundle_t bundle, struct starpu_task *t
 	/* Mark the task as belonging the bundle */
 	task->bundle = bundle;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 	return 0;
 }
 
@@ -92,7 +92,7 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
 {
 	struct _starpu_task_bundle_entry *item;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	item = bundle->list;
 
@@ -100,7 +100,7 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
 	 * belong to it */
 	if (!item)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 		return -ENOENT;
 	}
 
@@ -116,12 +116,12 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
 		/* If the list is now empty, deinitialize the bundle */
 		if (bundle->closed && bundle->list == NULL)
 		{
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 			_starpu_task_bundle_destroy(bundle);
 			return 0;
 		}
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 		return 0;
 	}
 
@@ -136,7 +136,7 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
 		{
 			/* Remove the next element */
 			item->next = next->next;
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 			free(next);
 			return 0;
 		}
@@ -144,7 +144,7 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
 		item = next;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 
 	/* We could not find the task in the bundle */
 	return -ENOENT;
@@ -155,13 +155,13 @@ int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *t
  * deinitialized when it becomes empty. A closed bundle cannot be reopened. */
 void starpu_task_bundle_close(starpu_task_bundle_t bundle)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&bundle->mutex);
 
 	/* If the bundle is already empty, we deinitialize it now as the
 	 * user closed it and thus don't intend to insert new tasks in it. */
 	if (bundle->list == NULL)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 		_starpu_task_bundle_destroy(bundle);
 		return;
 	}
@@ -169,7 +169,7 @@ void starpu_task_bundle_close(starpu_task_bundle_t bundle)
 	/* Mark the bundle as closed */
 	bundle->closed = 1;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&bundle->mutex);
 
 }
 
@@ -183,7 +183,7 @@ void _starpu_task_bundle_destroy(starpu_task_bundle_t bundle)
 		free(entry);
 	}
 
-	_STARPU_PTHREAD_MUTEX_DESTROY(&bundle->mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&bundle->mutex);
 
 	free(bundle);
 }

src/core/workers.c

@@ -338,10 +338,10 @@ void _starpu_worker_init(struct _starpu_worker *worker, unsigned fut_key)
 
 	_starpu_set_local_worker_key(worker);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&worker->mutex);
 	worker->worker_is_running = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&worker->started_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&worker->started_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&worker->mutex);
 
 }
 
@@ -350,7 +350,7 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 	pconfig->running = 1;
 	pconfig->submitting = 1;
 
-	_STARPU_PTHREAD_KEY_CREATE(&worker_key, NULL);
+	STARPU_PTHREAD_KEY_CREATE(&worker_key, NULL);
 
 	unsigned nworkers = pconfig->topology.nworkers;
 
@@ -379,9 +379,9 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 
 		_starpu_barrier_counter_init(&workerarg->tasks_barrier, 0);
 
-		_STARPU_PTHREAD_MUTEX_INIT(&workerarg->mutex, NULL);
-		_STARPU_PTHREAD_COND_INIT(&workerarg->started_cond, NULL);
-		_STARPU_PTHREAD_COND_INIT(&workerarg->ready_cond, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&workerarg->mutex, NULL);
+		STARPU_PTHREAD_COND_INIT(&workerarg->started_cond, NULL);
+		STARPU_PTHREAD_COND_INIT(&workerarg->ready_cond, NULL);
 
 		workerarg->worker_size = 1;
 		workerarg->combined_workerid = workerarg->workerid;
@@ -398,8 +398,8 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 		for(ctx = 0; ctx < STARPU_NMAX_SCHED_CTXS; ctx++)
 			workerarg->removed_from_ctx[ctx] = 0;
 
-		_STARPU_PTHREAD_MUTEX_INIT(&workerarg->sched_mutex, NULL);
-		_STARPU_PTHREAD_COND_INIT(&workerarg->sched_cond, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&workerarg->sched_mutex, NULL);
+		STARPU_PTHREAD_COND_INIT(&workerarg->sched_cond, NULL);
 
 		/* if some codelet's termination cannot be handled directly :
 		 * for instance in the Gordon driver, Gordon tasks' callbacks
@@ -426,7 +426,7 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 				driver.id.cpu_id = cpu;
 				if (_starpu_may_launch_driver(pconfig->conf, &driver))
 				{
-					_STARPU_PTHREAD_CREATE_ON(
+					STARPU_PTHREAD_CREATE_ON(
 						workerarg->name,
 						&workerarg->worker_thread,
 						NULL,
@@ -434,10 +434,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 						workerarg,
 						worker+1);
 #ifdef STARPU_USE_FXT
-					_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+					STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 					while (!workerarg->worker_is_running)
-						_STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
-					_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+						STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 #endif
 				}
 				else
@@ -453,7 +453,7 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 				driver.id.cuda_id = cuda;
 				if (_starpu_may_launch_driver(pconfig->conf, &driver))
 				{
-					_STARPU_PTHREAD_CREATE_ON(
+					STARPU_PTHREAD_CREATE_ON(
 						workerarg->name,
 						&workerarg->worker_thread,
 						NULL,
@@ -461,10 +461,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 						workerarg,
 						worker+1);
 #ifdef STARPU_USE_FXT
-					_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+					STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 					while (!workerarg->worker_is_running)
-						_STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
-					_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+						STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
+					STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 #endif
 				}
 				else
@@ -485,7 +485,7 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 				}
 #endif
 				workerarg->set = NULL;
-				_STARPU_PTHREAD_CREATE_ON(
+				STARPU_PTHREAD_CREATE_ON(
 					workerarg->name,
 					&workerarg->worker_thread,
 					NULL,
@@ -493,10 +493,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 					workerarg,
 					worker+1);
 #ifdef STARPU_USE_FXT
-				_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 				while (!workerarg->worker_is_running)
-					_STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+					STARPU_PTHREAD_COND_WAIT(&workerarg->started_cond, &workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 #endif
 				break;
 #endif
@@ -523,10 +523,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 					break;
 				}
 				_STARPU_DEBUG("waiting for worker %u initialization\n", worker);
-				_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 				while (!workerarg->worker_is_initialized)
-					_STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+					STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 				cpu++;
 				break;
 			case STARPU_CUDA_WORKER:
@@ -537,10 +537,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 					break;
 				}
 				_STARPU_DEBUG("waiting for worker %u initialization\n", worker);
-				_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 				while (!workerarg->worker_is_initialized)
-					_STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+					STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 				cuda++;
 				break;
 #if defined(STARPU_USE_OPENCL) || defined(STARPU_SIMGRID)
@@ -551,10 +551,10 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 					break;
 #endif
 				_STARPU_DEBUG("waiting for worker %u initialization\n", worker);
-				_STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&workerarg->mutex);
 				while (!workerarg->worker_is_initialized)
-					_STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
+					STARPU_PTHREAD_COND_WAIT(&workerarg->ready_cond, &workerarg->mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&workerarg->mutex);
 				break;
 #endif
 			default:
@@ -567,12 +567,12 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *pconfig)
 
 void _starpu_set_local_worker_key(struct _starpu_worker *worker)
 {
-	_STARPU_PTHREAD_SETSPECIFIC(worker_key, worker);
+	STARPU_PTHREAD_SETSPECIFIC(worker_key, worker);
 }
 
 struct _starpu_worker *_starpu_get_local_worker_key(void)
 {
-	return (struct _starpu_worker *) _STARPU_PTHREAD_GETSPECIFIC(worker_key);
+	return (struct _starpu_worker *) STARPU_PTHREAD_GETSPECIFIC(worker_key);
 }
 
 /* Initialize the starpu_conf with default values */
@@ -706,20 +706,20 @@ int starpu_init(struct starpu_conf *user_conf)
 #endif
 #endif
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 	while (initialized == CHANGING)
 		/* Wait for the other one changing it */
-		_STARPU_PTHREAD_COND_WAIT(&init_cond, &init_mutex);
+		STARPU_PTHREAD_COND_WAIT(&init_cond, &init_mutex);
 	init_count++;
 	if (initialized == INITIALIZED)
 	{
 		/* He initialized it, don't do it again, and let the others get the mutex */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 		return 0;
 	}
 	/* initialized == UNINITIALIZED */
 	initialized = CHANGING;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 
 #ifdef __MINGW32__
 	WSADATA wsadata;
@@ -783,12 +783,12 @@ int starpu_init(struct starpu_conf *user_conf)
 	ret = _starpu_build_topology(&config);
 	if (ret)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 		init_count--;
 		initialized = UNINITIALIZED;
 		/* Let somebody else try to do it */
-		_STARPU_PTHREAD_COND_SIGNAL(&init_cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&init_cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 		return ret;
 	}
 
@@ -803,11 +803,11 @@ int starpu_init(struct starpu_conf *user_conf)
 	/* Launch "basic" workers (ie. non-combined workers) */
 	_starpu_launch_drivers(&config);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 	initialized = INITIALIZED;
 	/* Tell everybody that we initialized */
-	_STARPU_PTHREAD_COND_BROADCAST(&init_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&init_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 
 	_STARPU_DEBUG("Initialisation finished\n");
 	return 0;
@@ -935,18 +935,18 @@ void starpu_display_stats()
 
 void starpu_shutdown(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 	init_count--;
 	if (init_count)
 	{
 		_STARPU_DEBUG("Still somebody needing StarPU, don't deinitialize\n");
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 		return;
 	}
 
 	/* We're last */
 	initialized = CHANGING;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 
 	starpu_task_wait_for_no_ready();
 
@@ -995,11 +995,11 @@ void starpu_shutdown(void)
 
 	_starpu_close_debug_logfile();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 	initialized = UNINITIALIZED;
 	/* Let someone else that wants to initialize it again do it */
-	_STARPU_PTHREAD_COND_SIGNAL(&init_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&init_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&init_mutex);
 
 	/* Clear memory if it was allocated by StarPU */
 	if (config.default_conf)

src/datawizard/coherency.c

@@ -744,7 +744,7 @@ unsigned _starpu_is_data_present_or_requested(starpu_data_handle_t handle, unsig
 	unsigned ret = 0;
 
 // XXX : this is just a hint, so we don't take the lock ...
-//	_STARPU_PTHREAD_SPIN_LOCK(&handle->header_lock);
+//	STARPU_PTHREAD_SPIN_LOCK(&handle->header_lock);
 
 	if (handle->per_node[node].state != STARPU_INVALID)
 	{
@@ -763,7 +763,7 @@ unsigned _starpu_is_data_present_or_requested(starpu_data_handle_t handle, unsig
 
 	}
 
-//	_STARPU_PTHREAD_SPIN_UNLOCK(&handle->header_lock);
+//	STARPU_PTHREAD_SPIN_UNLOCK(&handle->header_lock);
 
 	return ret;
 }

src/datawizard/copy_driver.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2013  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2013  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -39,7 +39,7 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 
 	struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
 	unsigned nconds = descr->condition_count[nodeid];
 	for (cond_id = 0; cond_id < nconds; cond_id++)
@@ -48,12 +48,12 @@ 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_COND_BROADCAST(condition->cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
+		STARPU_PTHREAD_COND_BROADCAST(condition->cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
 }
 
 void starpu_wake_all_blocked_workers(void)
@@ -63,7 +63,7 @@ void starpu_wake_all_blocked_workers(void)
 
 	struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
 
-	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
 	unsigned nconds = descr->total_condition_count;
 	for (cond_id = 0; cond_id < nconds; cond_id++)
@@ -72,12 +72,12 @@ 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_COND_BROADCAST(condition->cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
+		STARPU_PTHREAD_COND_BROADCAST(condition->cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
 }
 
 #ifdef STARPU_USE_FXT
@@ -446,10 +446,10 @@ int starpu_interface_copy(uintptr_t src, size_t src_offset, unsigned src_node, u
 void _starpu_driver_wait_request_completion(struct _starpu_async_channel *async_channel)
 {
 #ifdef STARPU_SIMGRID
-	_STARPU_PTHREAD_MUTEX_LOCK(&async_channel->event.mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&async_channel->event.mutex);
 	while (!async_channel->event.finished)
-		_STARPU_PTHREAD_COND_WAIT(&async_channel->event.cond, &async_channel->event.mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&async_channel->event.mutex);
+		STARPU_PTHREAD_COND_WAIT(&async_channel->event.cond, &async_channel->event.mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&async_channel->event.mutex);
 #else /* !SIMGRID */
 	enum starpu_node_kind kind = async_channel->type;
 #ifdef STARPU_USE_CUDA
@@ -499,9 +499,9 @@ unsigned _starpu_driver_test_request_completion(struct _starpu_async_channel *as
 {
 #ifdef STARPU_SIMGRID
 	unsigned ret;
-	_STARPU_PTHREAD_MUTEX_LOCK(&async_channel->event.mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&async_channel->event.mutex);
 	ret = async_channel->event.finished;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&async_channel->event.mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&async_channel->event.mutex);
 	return ret;
 #else /* !SIMGRID */
 	enum starpu_node_kind kind = async_channel->type;

src/datawizard/data_request.c

@@ -36,10 +36,10 @@ void _starpu_init_data_request_lists(void)
 	{
 		prefetch_requests[i] = _starpu_data_request_list_new();
 		data_requests[i] = _starpu_data_request_list_new();
-		_STARPU_PTHREAD_MUTEX_INIT(&data_requests_list_mutex[i], NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&data_requests_list_mutex[i], NULL);
 
 		data_requests_pending[i] = _starpu_data_request_list_new();
-		_STARPU_PTHREAD_MUTEX_INIT(&data_requests_pending_list_mutex[i], NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&data_requests_pending_list_mutex[i], NULL);
 	}
 }
 
@@ -48,10 +48,10 @@ void _starpu_deinit_data_request_lists(void)
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
-		_STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_pending_list_mutex[i]);
+		STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_pending_list_mutex[i]);
 		_starpu_data_request_list_delete(data_requests_pending[i]);
 
-		_STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_list_mutex[i]);
+		STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_list_mutex[i]);
 		_starpu_data_request_list_delete(data_requests[i]);
 		_starpu_data_request_list_delete(prefetch_requests[i]);
 	}
@@ -195,12 +195,12 @@ void _starpu_post_data_request(struct _starpu_data_request *r, unsigned handling
 	}
 
 	/* insert the request in the proper list */
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[handling_node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[handling_node]);
 	if (r->prefetch)
 		_starpu_data_request_list_push_back(prefetch_requests[handling_node], r);
 	else
 		_starpu_data_request_list_push_back(data_requests[handling_node], r);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[handling_node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[handling_node]);
 
 #ifndef STARPU_NON_BLOCKING_DRIVERS
 	_starpu_wake_all_blocked_workers_on_node(handling_node);
@@ -373,9 +373,9 @@ static int starpu_handle_data_request(struct _starpu_data_request *r, unsigned m
 		 * requests in the meantime. */
 		_starpu_spin_unlock(&handle->header_lock);
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[r->handling_node]);
+		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[r->handling_node]);
 		_starpu_data_request_list_push_front(data_requests_pending[r->handling_node], r);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[r->handling_node]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[r->handling_node]);
 
 		return -EAGAIN;
 	}
@@ -406,14 +406,14 @@ void _starpu_handle_node_data_requests(unsigned src_node, unsigned may_alloc)
 	VALGRIND_HG_MUTEX_UNLOCK_POST(&data_requests_list_mutex[src_node]);
 
 	/* take all the entries from the request list */
-        _STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
+        STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
 
 	struct _starpu_data_request_list *local_list = data_requests[src_node];
 
 	if (_starpu_data_request_list_empty(local_list))
 	{
 		/* there is no request */
-                _STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+                STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 
 		return;
 	}
@@ -423,7 +423,7 @@ void _starpu_handle_node_data_requests(unsigned src_node, unsigned may_alloc)
 	 * list, without concurrency issues.*/
 	data_requests[src_node] = _starpu_data_request_list_new();
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 
 	new_data_requests = _starpu_data_request_list_new();
 
@@ -443,9 +443,9 @@ void _starpu_handle_node_data_requests(unsigned src_node, unsigned may_alloc)
 
 	if (!_starpu_data_request_list_empty(new_data_requests))
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
 		_starpu_data_request_list_push_list_front(new_data_requests, data_requests[src_node]);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 	}
 
 	_starpu_data_request_list_delete(new_data_requests);
@@ -462,14 +462,14 @@ void _starpu_handle_node_prefetch_requests(unsigned src_node, unsigned may_alloc
 		return;
 
 	/* take all the entries from the request list */
-        _STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
+        STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
 
 	struct _starpu_data_request_list *local_list = prefetch_requests[src_node];
 
 	if (_starpu_data_request_list_empty(local_list))
 	{
 		/* there is no request */
-                _STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+                STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 		return;
 	}
 
@@ -478,7 +478,7 @@ void _starpu_handle_node_prefetch_requests(unsigned src_node, unsigned may_alloc
 	 * list, without concurrency issues.*/
 	prefetch_requests[src_node] = _starpu_data_request_list_new();
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 
 	new_data_requests = _starpu_data_request_list_new();
 	new_prefetch_requests = _starpu_data_request_list_new();
@@ -516,12 +516,12 @@ void _starpu_handle_node_prefetch_requests(unsigned src_node, unsigned may_alloc
 
 	if (!(_starpu_data_request_list_empty(new_data_requests) && _starpu_data_request_list_empty(new_prefetch_requests)))
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
 		if (!(_starpu_data_request_list_empty(new_data_requests)))
 			_starpu_data_request_list_push_list_front(new_data_requests, data_requests[src_node]);
 		if (!(_starpu_data_request_list_empty(new_prefetch_requests)))
 			_starpu_data_request_list_push_list_front(new_prefetch_requests, prefetch_requests[src_node]);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 	}
 
 	_starpu_data_request_list_delete(new_data_requests);
@@ -538,19 +538,19 @@ static void _handle_pending_node_data_requests(unsigned src_node, unsigned force
 	if (_starpu_data_request_list_empty(data_requests_pending[src_node]))
 		return;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
 
 	/* for all entries of the list */
 	struct _starpu_data_request_list *local_list = data_requests_pending[src_node];
 	if (_starpu_data_request_list_empty(local_list))
 	{
 		/* there is no request */
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
 		return;
 	}
 	data_requests_pending[src_node] = _starpu_data_request_list_new();
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
 
 	new_data_requests_pending = _starpu_data_request_list_new();
 
@@ -592,9 +592,9 @@ static void _handle_pending_node_data_requests(unsigned src_node, unsigned force
 	}
 	if (!_starpu_data_request_list_empty(new_data_requests_pending))
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
 		_starpu_data_request_list_push_list_back(data_requests_pending[src_node], new_data_requests_pending);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
 	}
 
 	_starpu_data_request_list_delete(local_list);
@@ -617,12 +617,12 @@ int _starpu_check_that_no_data_request_exists(unsigned node)
 	int no_request;
 	int no_pending;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[node]);
 	no_request = _starpu_data_request_list_empty(data_requests[node]);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[node]);
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[node]);
 	no_pending = _starpu_data_request_list_empty(data_requests_pending[node]);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[node]);
 
 	return (no_request && no_pending);
 }
@@ -642,7 +642,7 @@ void _starpu_update_prefetch_status(struct _starpu_data_request *r)
 			_starpu_update_prefetch_status(next_req);
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[r->handling_node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[r->handling_node]);
 
 	/* The request can be in a different list (handling request or the temp list)
 	 * we have to check that it is really in the prefetch list. */
@@ -659,5 +659,5 @@ void _starpu_update_prefetch_status(struct _starpu_data_request *r)
 			break;
 		}
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[r->handling_node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[r->handling_node]);
 }

src/datawizard/filters.c

@@ -175,14 +175,14 @@ void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_da
 		child->refcnt = 0;
 		child->busy_count = 0;
 		child->busy_waiting = 0;
-		_STARPU_PTHREAD_MUTEX_INIT(&child->busy_mutex, NULL);
-		_STARPU_PTHREAD_COND_INIT(&child->busy_cond, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&child->busy_mutex, NULL);
+		STARPU_PTHREAD_COND_INIT(&child->busy_cond, NULL);
 		child->reduction_refcnt = 0;
 		_starpu_spin_init(&child->header_lock);
 
 		child->sequential_consistency = initial_handle->sequential_consistency;
 
-		_STARPU_PTHREAD_MUTEX_INIT(&child->sequential_consistency_mutex, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&child->sequential_consistency_mutex, NULL);
 		child->last_submitted_mode = STARPU_R;
 		child->last_submitted_writer = NULL;
 		child->last_submitted_readers = NULL;
@@ -399,9 +399,9 @@ void starpu_data_unpartition(starpu_data_handle_t root_handle, unsigned gatherin
 		_starpu_spin_unlock(&child_handle->header_lock);
 		_starpu_spin_destroy(&child_handle->header_lock);
 
-		_STARPU_PTHREAD_MUTEX_DESTROY(&child_handle->busy_mutex);
-		_STARPU_PTHREAD_COND_DESTROY(&child_handle->busy_cond);
-		_STARPU_PTHREAD_MUTEX_DESTROY(&child_handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_DESTROY(&child_handle->busy_mutex);
+		STARPU_PTHREAD_COND_DESTROY(&child_handle->busy_cond);
+		STARPU_PTHREAD_MUTEX_DESTROY(&child_handle->sequential_consistency_mutex);
 	}
 
 	/* there is no child anymore */

src/datawizard/interfaces/data_interface.c

@@ -140,8 +140,8 @@ static void _starpu_register_new_data(starpu_data_handle_t handle,
 	handle->refcnt = 0;
 	handle->busy_count = 0;
 	handle->busy_waiting = 0;
-	_STARPU_PTHREAD_MUTEX_INIT(&handle->busy_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&handle->busy_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&handle->busy_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&handle->busy_cond, NULL);
 	_starpu_spin_init(&handle->header_lock);
 
 	/* first take care to properly lock the data */
@@ -161,7 +161,7 @@ static void _starpu_register_new_data(starpu_data_handle_t handle,
 	handle->sequential_consistency =
 		starpu_data_get_default_sequential_consistency_flag();
 
-	_STARPU_PTHREAD_MUTEX_INIT(&handle->sequential_consistency_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&handle->sequential_consistency_mutex, NULL);
 	handle->last_submitted_mode = STARPU_R;
 	handle->last_submitted_writer = NULL;
 	handle->last_submitted_readers = NULL;
@@ -479,9 +479,9 @@ int _starpu_data_check_not_busy(starpu_data_handle_t handle)
 {
 	if (!handle->busy_count && handle->busy_waiting)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&handle->busy_mutex);
-		_STARPU_PTHREAD_COND_BROADCAST(&handle->busy_cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->busy_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&handle->busy_mutex);
+		STARPU_PTHREAD_COND_BROADCAST(&handle->busy_cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->busy_mutex);
 	}
 
 	/* The handle has been destroyed in between (eg. this was a temporary
@@ -514,10 +514,10 @@ static void _starpu_data_unregister_fetch_data_callback(void *_arg)
 	STARPU_ASSERT(!ret);
 
 	/* unlock the caller */
-	_STARPU_PTHREAD_MUTEX_LOCK(&arg->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&arg->mutex);
 	arg->terminated = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&arg->cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&arg->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&arg->cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&arg->mutex);
 }
 
 /* Unregister the data handle, perhaps we don't need to update the home_node
@@ -541,8 +541,8 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 			arg.handle = handle;
 			arg.memory_node = (unsigned)home_node;
 			arg.terminated = 0;
-			_STARPU_PTHREAD_MUTEX_INIT(&arg.mutex, NULL);
-			_STARPU_PTHREAD_COND_INIT(&arg.cond, NULL);
+			STARPU_PTHREAD_MUTEX_INIT(&arg.mutex, NULL);
+			STARPU_PTHREAD_COND_INIT(&arg.cond, NULL);
 
 			if (!_starpu_attempt_to_submit_data_request_from_apps(handle, STARPU_R,
 					_starpu_data_unregister_fetch_data_callback, &arg))
@@ -554,13 +554,13 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 			}
 			else
 			{
-				_STARPU_PTHREAD_MUTEX_LOCK(&arg.mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&arg.mutex);
 				while (!arg.terminated)
-					_STARPU_PTHREAD_COND_WAIT(&arg.cond, &arg.mutex);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&arg.mutex);
+					STARPU_PTHREAD_COND_WAIT(&arg.cond, &arg.mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&arg.mutex);
 			}
-			_STARPU_PTHREAD_MUTEX_DESTROY(&arg.mutex);
-			_STARPU_PTHREAD_COND_DESTROY(&arg.cond);
+			STARPU_PTHREAD_MUTEX_DESTROY(&arg.mutex);
+			STARPU_PTHREAD_COND_DESTROY(&arg.cond);
 			_starpu_release_data_on_node(handle, 0, &handle->per_node[home_node]);
 		}
 
@@ -626,7 +626,7 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 	_starpu_spin_unlock(&handle->header_lock);
 
 	/* Wait for all requests to finish (notably WT requests) */
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->busy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->busy_mutex);
 	while (1) {
 		int busy;
 		/* Note: we here tell valgrind that reading busy_count is as
@@ -640,9 +640,9 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 			break;
 		/* This is woken by _starpu_data_check_not_busy, always called
 		 * after decrementing busy_count */
-		_STARPU_PTHREAD_COND_WAIT(&handle->busy_cond, &handle->busy_mutex);
+		STARPU_PTHREAD_COND_WAIT(&handle->busy_cond, &handle->busy_mutex);
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->busy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&handle->busy_mutex);
 
 	/* Wait for finished requests to release the handle */
 	_starpu_spin_lock(&handle->header_lock);
@@ -677,9 +677,9 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 	_starpu_spin_unlock(&handle->header_lock);
 	_starpu_spin_destroy(&handle->header_lock);
 
-	_STARPU_PTHREAD_MUTEX_DESTROY(&handle->busy_mutex);
-	_STARPU_PTHREAD_COND_DESTROY(&handle->busy_cond);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&handle->busy_mutex);
+	STARPU_PTHREAD_COND_DESTROY(&handle->busy_cond);
+	STARPU_PTHREAD_MUTEX_DESTROY(&handle->sequential_consistency_mutex);
 
 	starpu_data_release_tag(handle);
 

src/datawizard/malloc.c

@@ -365,10 +365,10 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 #warning TODO: record used memory, using a simgrid property to know the available memory
 #endif
 			/* Sleep 10µs for the allocation */
-			_STARPU_PTHREAD_MUTEX_LOCK(&cuda_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&cuda_alloc_mutex);
 			MSG_process_sleep(0.000010);
 			addr = 1;
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&cuda_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&cuda_alloc_mutex);
 #else
 			status = cudaMalloc((void **)&addr, size);
 			if (!addr || (status != cudaSuccess))
@@ -385,10 +385,10 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 			{
 #ifdef STARPU_SIMGRID
 				/* Sleep 10µs for the allocation */
-				_STARPU_PTHREAD_MUTEX_LOCK(&opencl_alloc_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&opencl_alloc_mutex);
 				MSG_process_sleep(0.000010);
 				addr = 1;
-				_STARPU_PTHREAD_MUTEX_UNLOCK(&opencl_alloc_mutex);
+				STARPU_PTHREAD_MUTEX_UNLOCK(&opencl_alloc_mutex);
 #else
                                 int ret;
 				cl_mem ptr;
@@ -431,10 +431,10 @@ starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
 		case STARPU_CUDA_RAM:
 		{
 #ifdef STARPU_SIMGRID
-			_STARPU_PTHREAD_MUTEX_LOCK(&cuda_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&cuda_alloc_mutex);
 			/* Sleep 10µs for the free */
 			MSG_process_sleep(0.000010);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&cuda_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&cuda_alloc_mutex);
 #else
 			cudaError_t err;
 			err = cudaFree((void*)addr);
@@ -448,10 +448,10 @@ starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
                 case STARPU_OPENCL_RAM:
 		{
 #ifdef STARPU_SIMGRID
-			_STARPU_PTHREAD_MUTEX_LOCK(&opencl_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(&opencl_alloc_mutex);
 			/* Sleep 10µs for the free */
 			MSG_process_sleep(0.000010);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&opencl_alloc_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&opencl_alloc_mutex);
 #else
 			cl_int err;
                         err = clReleaseMemObject((void*)addr);

src/datawizard/memalloc.c

@@ -46,7 +46,7 @@ void _starpu_init_mem_chunk_lists(void)
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
-		_STARPU_PTHREAD_RWLOCK_INIT(&mc_rwlock[i], NULL);
+		STARPU_PTHREAD_RWLOCK_INIT(&mc_rwlock[i], NULL);
 		_starpu_spin_init(&lru_rwlock[i]);
 		mc_list[i] = _starpu_mem_chunk_list_new();
 		starpu_lru_list[i] = _starpu_mem_chunk_lru_list_new();
@@ -63,7 +63,7 @@ void _starpu_deinit_mem_chunk_lists(void)
 		_starpu_mem_chunk_list_delete(memchunk_cache[i]);
 		_starpu_mem_chunk_lru_list_delete(starpu_lru_list[i]);
 		_starpu_spin_destroy(&lru_rwlock[i]);
-		_STARPU_PTHREAD_RWLOCK_DESTROY(&mc_rwlock[i]);
+		STARPU_PTHREAD_RWLOCK_DESTROY(&mc_rwlock[i]);
 	}
 }
 
@@ -528,10 +528,10 @@ static size_t flush_memchunk_cache(unsigned node, size_t reclaim)
 
 	size_t freed = 0;
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 	while (!_starpu_mem_chunk_list_empty(memchunk_cache[node])) {
 		mc = _starpu_mem_chunk_list_pop_front(memchunk_cache[node]);
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 
 		starpu_data_handle_t handle = mc->data;
 
@@ -545,11 +545,11 @@ static size_t flush_memchunk_cache(unsigned node, size_t reclaim)
 		free(mc->chunk_interface);
 		_starpu_mem_chunk_delete(mc);
 
-		_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+		STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 		if (reclaim && freed>reclaim)
 			break;
 	}
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 	return freed;
 }
 
@@ -575,7 +575,7 @@ static size_t free_potentially_in_use_mc(unsigned node, unsigned force, size_t r
 
 	while (1)
 	{
-		_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+		STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 		/* A priori, start from the beginning */
 		mc = _starpu_mem_chunk_list_begin(mc_list[node]);
 		if (next_mc)
@@ -590,12 +590,12 @@ static size_t free_potentially_in_use_mc(unsigned node, unsigned force, size_t r
 		if (mc == _starpu_mem_chunk_list_end(mc_list[node]))
 		{
 			/* But it was the last one of the list :/ */
-			_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+			STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 			break;
 		}
 		/* Remember where to try next */
 		next_mc = _starpu_mem_chunk_list_next(mc);
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 
 		if (!force)
 		{
@@ -685,11 +685,11 @@ static void register_mem_chunk(struct _starpu_data_replicate *replicate, unsigne
 	/* Put this memchunk in the list of memchunk in use */
 	mc = _starpu_memchunk_init(replicate, interface_size, automatically_allocated);
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[dst_node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[dst_node]);
 
 	_starpu_mem_chunk_list_push_back(mc_list[dst_node], mc);
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
 }
 
 /* This function is called when the handle is destroyed (eg. when calling
@@ -712,13 +712,13 @@ void _starpu_request_mem_chunk_removal(starpu_data_handle_t handle, struct _star
 	replicate->allocated = 0;
 	replicate->automatically_allocated = 0;
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 
 	mc->data = NULL;
 	/* remove it from the main list */
 	_starpu_mem_chunk_list_erase(mc_list[node], mc);
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 
 	/* We would never flush the node 0 cache, unless
 	 * malloc() returns NULL, which is very unlikely... */
@@ -764,17 +764,17 @@ static starpu_ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, st
 	uint32_t footprint = _starpu_compute_data_footprint(handle);
 
 	_STARPU_TRACE_START_ALLOC_REUSE(dst_node);
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[dst_node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[dst_node]);
 
 	if (try_to_find_reusable_mem_chunk(dst_node, handle, replicate, footprint))
 	{
-		_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
+		STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
 		_starpu_allocation_cache_hit(dst_node);
 		starpu_ssize_t data_size = _starpu_data_get_size(handle);
 		return data_size;
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[dst_node]);
 	_STARPU_TRACE_END_ALLOC_REUSE(dst_node);
 #endif
 
@@ -909,7 +909,7 @@ static void _starpu_memchunk_recently_used_move(struct _starpu_mem_chunk *mc, un
 
 static void starpu_lru(unsigned node)
 {
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 
 	_starpu_spin_lock(&lru_rwlock[node]);
 	while (!_starpu_mem_chunk_lru_list_empty(starpu_lru_list[node]))
@@ -921,13 +921,13 @@ static void starpu_lru(unsigned node)
 	}
 	_starpu_spin_unlock(&lru_rwlock[node]);
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 }
 
 #ifdef STARPU_MEMORY_STATS
 void _starpu_memory_display_stats_by_node(int node)
 {
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 
 	if (!_starpu_mem_chunk_list_empty(mc_list[node]))
 	{
@@ -946,7 +946,7 @@ void _starpu_memory_display_stats_by_node(int node)
 
 	}
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
 }
 #endif
 

src/datawizard/memory_manager.c

@@ -31,7 +31,7 @@ int _starpu_memory_manager_init()
 	{
 		global_size[i] = 0;
 		used_size[i] = 0;
-		_STARPU_PTHREAD_MUTEX_INIT(&lock_nodes[i], NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&lock_nodes[i], NULL);
 	}
 	return 0;
 }
@@ -52,7 +52,7 @@ int _starpu_memory_manager_can_allocate_size(size_t size, unsigned node)
 {
 	int ret;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&lock_nodes[node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&lock_nodes[node]);
 	if (global_size[node] == 0)
 	{
 		// We do not have information on the available size, let's suppose it is going to fit
@@ -68,15 +68,15 @@ int _starpu_memory_manager_can_allocate_size(size_t size, unsigned node)
 	{
 		ret = 0;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&lock_nodes[node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&lock_nodes[node]);
 	return ret;
 }
 
 void _starpu_memory_manager_deallocate_size(size_t size, unsigned node)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&lock_nodes[node]);
+	STARPU_PTHREAD_MUTEX_LOCK(&lock_nodes[node]);
 	used_size[node] -= size;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&lock_nodes[node]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&lock_nodes[node]);
 }
 
 starpu_ssize_t starpu_memory_get_available(unsigned node)

src/datawizard/memory_nodes.c

@@ -32,7 +32,7 @@ void _starpu_memory_nodes_init(void)
 	 * added using _starpu_memory_node_register */
 	descr.nnodes = 0;
 
-	_STARPU_PTHREAD_KEY_CREATE(&memory_node_key, NULL);
+	STARPU_PTHREAD_KEY_CREATE(&memory_node_key, NULL);
 
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
@@ -45,7 +45,7 @@ void _starpu_memory_nodes_init(void)
 	_starpu_init_data_request_lists();
 	_starpu_memory_manager_init();
 
-	_STARPU_PTHREAD_RWLOCK_INIT(&descr.conditions_rwlock, NULL);
+	STARPU_PTHREAD_RWLOCK_INIT(&descr.conditions_rwlock, NULL);
 	descr.total_condition_count = 0;
 }
 
@@ -54,19 +54,19 @@ void _starpu_memory_nodes_deinit(void)
 	_starpu_deinit_data_request_lists();
 	_starpu_deinit_mem_chunk_lists();
 
-	_STARPU_PTHREAD_RWLOCK_DESTROY(&descr.conditions_rwlock);
-	_STARPU_PTHREAD_KEY_DELETE(memory_node_key);
+	STARPU_PTHREAD_RWLOCK_DESTROY(&descr.conditions_rwlock);
+	STARPU_PTHREAD_KEY_DELETE(memory_node_key);
 }
 
 void _starpu_memory_node_set_local_key(unsigned *node)
 {
-	_STARPU_PTHREAD_SETSPECIFIC(memory_node_key, node);
+	STARPU_PTHREAD_SETSPECIFIC(memory_node_key, node);
 }
 
 unsigned _starpu_memory_node_get_local_key(void)
 {
 	unsigned *memory_node;
-	memory_node = (unsigned *) _STARPU_PTHREAD_GETSPECIFIC(memory_node_key);
+	memory_node = (unsigned *) STARPU_PTHREAD_GETSPECIFIC(memory_node_key);
 
 	/* in case this is called by the programmer, we assume the RAM node
 	   is the appropriate memory node ... so we return 0 XXX */
@@ -143,7 +143,7 @@ void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_
 	unsigned cond_id;
 	unsigned nconds_total, nconds;
 
-	_STARPU_PTHREAD_RWLOCK_WRLOCK(&descr.conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_WRLOCK(&descr.conditions_rwlock);
 
 	/* we only insert the queue if it's not already in the list */
 	nconds = descr.condition_count[nodeid];
@@ -154,7 +154,7 @@ void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_
 			STARPU_ASSERT(descr.conditions_attached_to_node[nodeid][cond_id].mutex == mutex);
 
 			/* the condition is already in the list */
-			_STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
+			STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
 			return;
 		}
 	}
@@ -171,7 +171,7 @@ void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_
 		if (descr.conditions_all[cond_id].cond == cond)
 		{
 			/* the queue is already in the global list */
-			_STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
+			STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
 			return;
 		}
 	}
@@ -181,7 +181,7 @@ void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_
 	descr.conditions_all[nconds_total].mutex = mutex;
 	descr.total_condition_count++;
 
-	_STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
+	STARPU_PTHREAD_RWLOCK_UNLOCK(&descr.conditions_rwlock);
 }
 
 unsigned starpu_worker_get_memory_node(unsigned workerid)

src/datawizard/user_interactions.c

@@ -129,11 +129,11 @@ int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, unsigned node,
 	wrapper->mode = mode;
 	wrapper->callback = callback;
 	wrapper->callback_arg = arg;
-	_STARPU_PTHREAD_COND_INIT(&wrapper->cond, NULL);
-	_STARPU_PTHREAD_MUTEX_INIT(&wrapper->lock, NULL);
+	STARPU_PTHREAD_COND_INIT(&wrapper->cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&wrapper->lock, NULL);
 	wrapper->finished = 0;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 	int sequential_consistency = handle->sequential_consistency;
 	if (sequential_consistency)
 	{
@@ -154,7 +154,7 @@ int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, unsigned node,
 #endif
 
 		new_task = _starpu_detect_implicit_data_deps_with_handle(wrapper->pre_sync_task, wrapper->post_sync_task, handle, mode);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 		if (new_task)
 		{
@@ -168,7 +168,7 @@ int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, unsigned node,
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 		starpu_data_acquire_cb_pre_sync_callback(wrapper);
 	}
@@ -199,10 +199,10 @@ static inline void _starpu_data_acquire_continuation(void *arg)
 	_starpu_fetch_data_on_node(handle, replicate, wrapper->mode, 0, 0, NULL, NULL);
 
 	/* continuation of starpu_data_acquire */
-	_STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
+	STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
 	wrapper->finished = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&wrapper->cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
+	STARPU_PTHREAD_COND_SIGNAL(&wrapper->cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
 }
 
 /* The data must be released by calling starpu_data_release later on */
@@ -242,11 +242,11 @@ int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum
 		.finished = 0
 	};
 
-	_STARPU_PTHREAD_COND_INIT(&wrapper.cond, NULL);
-	_STARPU_PTHREAD_MUTEX_INIT(&wrapper.lock, NULL);
+	STARPU_PTHREAD_COND_INIT(&wrapper.cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&wrapper.lock, NULL);
 
 //	_STARPU_DEBUG("TAKE sequential_consistency_mutex starpu_data_acquire\n");
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 	int sequential_consistency = handle->sequential_consistency;
 	if (sequential_consistency)
 	{
@@ -265,7 +265,7 @@ int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum
 #endif
 
 		new_task = _starpu_detect_implicit_data_deps_with_handle(wrapper.pre_sync_task, wrapper.post_sync_task, handle, mode);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 		if (new_task)
 		{
 			int ret = _starpu_task_submit_internally(new_task);
@@ -279,7 +279,7 @@ int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 	}
 
 	/* we try to get the data, if we do not succeed immediately, we set a
@@ -294,13 +294,13 @@ int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&wrapper.lock);
+		STARPU_PTHREAD_MUTEX_LOCK(&wrapper.lock);
 		while (!wrapper.finished)
-			_STARPU_PTHREAD_COND_WAIT(&wrapper.cond, &wrapper.lock);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper.lock);
+			STARPU_PTHREAD_COND_WAIT(&wrapper.cond, &wrapper.lock);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper.lock);
 	}
-	_STARPU_PTHREAD_COND_DESTROY(&wrapper.cond);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&wrapper.lock);
+	STARPU_PTHREAD_COND_DESTROY(&wrapper.cond);
+	STARPU_PTHREAD_MUTEX_DESTROY(&wrapper.lock);
 
 	/* At that moment, the caller holds a reference to the piece of data.
 	 * We enqueue the "post" sync task in the list associated to the handle
@@ -349,10 +349,10 @@ static void _prefetch_data_on_node(void *arg)
 		free(wrapper);
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
+		STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
 		wrapper->finished = 1;
-		_STARPU_PTHREAD_COND_SIGNAL(&wrapper->cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
+		STARPU_PTHREAD_COND_SIGNAL(&wrapper->cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
 	}
 
 	_starpu_spin_lock(&handle->header_lock);
@@ -374,8 +374,8 @@ int _starpu_prefetch_data_on_node_with_mode(starpu_data_handle_t handle, unsigne
 	wrapper->handle = handle;
 	wrapper->node = node;
 	wrapper->async = async;
-	_STARPU_PTHREAD_COND_INIT(&wrapper->cond, NULL);
-	_STARPU_PTHREAD_MUTEX_INIT(&wrapper->lock, NULL);
+	STARPU_PTHREAD_COND_INIT(&wrapper->cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&wrapper->lock, NULL);
 	wrapper->finished = 0;
 
 	if (!_starpu_attempt_to_submit_data_request_from_apps(handle, mode, _prefetch_data_on_node, wrapper))
@@ -383,8 +383,8 @@ int _starpu_prefetch_data_on_node_with_mode(starpu_data_handle_t handle, unsigne
 		/* we can immediately proceed */
 		struct _starpu_data_replicate *replicate = &handle->per_node[node];
 
-		_STARPU_PTHREAD_COND_DESTROY(&wrapper->cond);
-		_STARPU_PTHREAD_MUTEX_DESTROY(&wrapper->lock);
+		STARPU_PTHREAD_COND_DESTROY(&wrapper->cond);
+		STARPU_PTHREAD_MUTEX_DESTROY(&wrapper->lock);
 		free(wrapper);
 
 		_starpu_fetch_data_on_node(handle, replicate, mode, async, async, NULL, NULL);
@@ -410,12 +410,12 @@ int _starpu_prefetch_data_on_node_with_mode(starpu_data_handle_t handle, unsigne
 	}
 	else if (!async)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
+		STARPU_PTHREAD_MUTEX_LOCK(&wrapper->lock);
 		while (!wrapper->finished)
-			_STARPU_PTHREAD_COND_WAIT(&wrapper->cond, &wrapper->lock);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
-		_STARPU_PTHREAD_COND_DESTROY(&wrapper->cond);
-		_STARPU_PTHREAD_MUTEX_DESTROY(&wrapper->lock);
+			STARPU_PTHREAD_COND_WAIT(&wrapper->cond, &wrapper->lock);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&wrapper->lock);
+		STARPU_PTHREAD_COND_DESTROY(&wrapper->cond);
+		STARPU_PTHREAD_MUTEX_DESTROY(&wrapper->lock);
 		free(wrapper);
 	}
 
@@ -465,9 +465,9 @@ void starpu_data_set_sequential_consistency_flag(starpu_data_handle_t handle, un
 			starpu_data_set_sequential_consistency_flag(child_handle, flag);
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 	handle->sequential_consistency = flag;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 
 	_starpu_spin_unlock(&handle->header_lock);
 }

src/drivers/cpu/driver_cpu.c

@@ -136,7 +136,7 @@ static int execute_job_on_cpu(struct _starpu_job *j, struct starpu_task *worker_
 
 	if (is_parallel_task)
 	{
-		_STARPU_PTHREAD_BARRIER_WAIT(&j->before_work_barrier);
+		STARPU_PTHREAD_BARRIER_WAIT(&j->before_work_barrier);
 
 		/* In the case of a combined worker, the scheduler needs to know
 		 * when each actual worker begins the execution */
@@ -168,7 +168,7 @@ static int execute_job_on_cpu(struct _starpu_job *j, struct starpu_task *worker_
 	_starpu_driver_end_job(cpu_args, j, perf_arch, &codelet_end, rank, profiling);
 
 	if (is_parallel_task)
-		_STARPU_PTHREAD_BARRIER_WAIT(&j->after_work_barrier);
+		STARPU_PTHREAD_BARRIER_WAIT(&j->after_work_barrier);
 
 	if (rank == 0)
 	{
@@ -247,10 +247,10 @@ int _starpu_cpu_driver_init(struct starpu_driver *d)
 	_STARPU_TRACE_WORKER_INIT_END;
 
 	/* tell the main thread that we are ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&cpu_worker->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cpu_worker->mutex);
 	cpu_worker->worker_is_initialized = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cpu_worker->ready_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&cpu_worker->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&cpu_worker->ready_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cpu_worker->mutex);
 	return 0;
 }
 
@@ -294,9 +294,9 @@ int _starpu_cpu_driver_run_once(struct starpu_driver *d STARPU_ATTRIBUTE_UNUSED)
 	/* Get the rank in case it is a parallel task */
 	if (is_parallel_task)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&j->sync_mutex);
 		rank = j->active_task_alias_count++;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&j->sync_mutex);
 
 		struct _starpu_combined_worker *combined_worker;
 		combined_worker = _starpu_get_combined_worker_struct(j->combined_workerid);

src/drivers/cuda/driver_cuda.c

@@ -430,10 +430,10 @@ int _starpu_cuda_driver_init(struct starpu_driver *d)
 	_STARPU_TRACE_WORKER_INIT_END;
 
 	/* tell the main thread that this one is ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
 	args->worker_is_initialized = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&args->ready_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&args->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&args->ready_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&args->mutex);
 
 	return 0;
 }

src/drivers/driver_common/driver_common.c

@@ -155,7 +155,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *args, int wor
 {
 	struct starpu_task *task;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&args->sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&args->sched_mutex);
 	task = _starpu_pop_task(args);
 
 	if (task == NULL)
@@ -173,7 +173,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *args, int wor
 		}
 
 		if (_starpu_worker_can_block(memnode))
-			_STARPU_PTHREAD_COND_WAIT(&args->sched_cond, &args->sched_mutex);
+			STARPU_PTHREAD_COND_WAIT(&args->sched_cond, &args->sched_mutex);
 		else
 		{
 			if (_starpu_machine_is_running())
@@ -191,12 +191,12 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *args, int wor
 			}
 		}
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&args->sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&args->sched_mutex);
 
 		return NULL;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&args->sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&args->sched_mutex);
 
 	if (_starpu_worker_get_status(workerid) == STATUS_SLEEPING)
 	{

src/drivers/gordon/driver_gordon.c

@@ -57,10 +57,10 @@ void *gordon_worker_progress(void *arg)
 		(gordon_set_arg->workers[0].bindid + 1)%(gordon_set_arg->config->nhwcores);
 	_starpu_bind_thread_on_cpu(gordon_set_arg->config, prog_thread_bind_id);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&progress_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&progress_mutex);
 	progress_thread_is_inited = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&progress_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&progress_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&progress_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&progress_mutex);
 
 	while (1)
 	{
@@ -462,25 +462,24 @@ void *_starpu_gordon_worker(void *arg)
 	 */
 
 	/* launch the progression thread */
-	_STARPU_PTHREAD_MUTEX_INIT(&progress_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&progress_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&progress_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&progress_cond, NULL);
 
-	_STARPU_PTHREAD_CREATE("Gordon progress", &progress_thread, NULL,
-			       gordon_worker_progress, gordon_set_arg);
+	STARPU_PTHREAD_CREATE(&progress_thread, NULL, gordon_worker_progress, gordon_set_arg);
 
 	/* wait for the progression thread to be ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&progress_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&progress_mutex);
 	while (!progress_thread_is_inited)
-		_STARPU_PTHREAD_COND_WAIT(&progress_cond, &progress_mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&progress_mutex);
+		STARPU_PTHREAD_COND_WAIT(&progress_cond, &progress_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&progress_mutex);
 
 	_STARPU_DEBUG("progress thread is running ... \n");
 
 	/* tell the core that gordon is ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&gordon_set_arg->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&gordon_set_arg->mutex);
 	gordon_set_arg->set_is_initialized = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&gordon_set_arg->ready_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&gordon_set_arg->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&gordon_set_arg->ready_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&gordon_set_arg->mutex);
 
 	gordon_worker_inject(gordon_set_arg);
 

src/drivers/opencl/driver_opencl.c

@@ -132,7 +132,7 @@ cl_int _starpu_opencl_init_context(int devid)
 	cl_int err;
 	cl_uint uint;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
 
         _STARPU_DEBUG("Initialising context for dev %d\n", devid);
 
@@ -162,7 +162,7 @@ cl_int _starpu_opencl_init_context(int devid)
         alloc_queues[devid] = clCreateCommandQueue(contexts[devid], devices[devid], 0, &err);
         if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
 
 	return CL_SUCCESS;
 }
@@ -171,7 +171,7 @@ cl_int _starpu_opencl_deinit_context(int devid)
 {
         cl_int err;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
 
         _STARPU_DEBUG("De-initialising context for dev %d\n", devid);
 
@@ -189,7 +189,7 @@ cl_int _starpu_opencl_deinit_context(int devid)
 
         contexts[devid] = NULL;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
 
         return CL_SUCCESS;
 }
@@ -438,7 +438,7 @@ static size_t _starpu_opencl_get_global_mem_size(int devid)
 
 void _starpu_opencl_init(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_LOCK(&big_lock);
         if (!init_done)
 	{
 #ifdef STARPU_SIMGRID
@@ -538,7 +538,7 @@ void _starpu_opencl_init(void)
 
                 init_done=1;
         }
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
 }
 
 #ifndef STARPU_SIMGRID
@@ -624,10 +624,10 @@ int _starpu_opencl_driver_init(struct starpu_driver *d)
 	_STARPU_TRACE_WORKER_INIT_END;
 
 	/* tell the main thread that this one is ready */
-	_STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
 	args->worker_is_initialized = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&args->ready_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&args->mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&args->ready_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&args->mutex);
 
 	return 0;
 }

src/profiling/bound.c

@@ -129,7 +129,7 @@ void starpu_bound_start(int deps, int prio)
 	struct bound_task *t;
 	struct bound_tag_dep *td;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	tp = task_pools;
 	task_pools = NULL;
@@ -145,7 +145,7 @@ void starpu_bound_start(int deps, int prio)
 	recorddeps = deps;
 	recordprio = prio;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	while (tp != NULL)
 	{
@@ -220,11 +220,11 @@ void _starpu_bound_record(struct _starpu_job *j)
 	if (!good_job(j))
 		return;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	/* Re-check, this time with mutex held */
 	if (!_starpu_bound_recording)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return;
 	}
 
@@ -259,7 +259,7 @@ void _starpu_bound_record(struct _starpu_job *j)
 		tp->n++;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /* A tag dependency was emitted, record it */
@@ -270,11 +270,11 @@ void _starpu_bound_tag_dep(starpu_tag_t id, starpu_tag_t dep_id)
 	if (!_starpu_bound_recording || !recorddeps)
 		return;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	/* Re-check, this time with mutex held */
 	if (!_starpu_bound_recording || !recorddeps)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return;
 	}
 
@@ -283,7 +283,7 @@ void _starpu_bound_tag_dep(starpu_tag_t id, starpu_tag_t dep_id)
 	td->dep_tag = dep_id;
 	td->next = tag_deps;
 	tag_deps = td;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /* A task dependency was emitted, record it */
@@ -298,11 +298,11 @@ void _starpu_bound_task_dep(struct _starpu_job *j, struct _starpu_job *dep_j)
 	if (!good_job(j) || !good_job(dep_j))
 		return;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	/* Re-check, this time with mutex held */
 	if (!_starpu_bound_recording || !recorddeps)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return;
 	}
 
@@ -319,7 +319,7 @@ void _starpu_bound_task_dep(struct _starpu_job *j, struct _starpu_job *dep_j)
 		t->deps[t->depsn-1].dep = dep_j->bound_task;
 		t->deps[t->depsn-1].size = 0; /* We don't have data information in that case */
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /* Look for job with id ID among our tasks */
@@ -345,11 +345,11 @@ void _starpu_bound_job_id_dep(starpu_data_handle_t handle, struct _starpu_job *j
 	if (!good_job(j))
 		return;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	/* Re-check, this time with mutex held */
 	if (!_starpu_bound_recording || !recorddeps)
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return;
 	}
 
@@ -358,7 +358,7 @@ void _starpu_bound_job_id_dep(starpu_data_handle_t handle, struct _starpu_job *j
 	if (!dep_t)
 	{
 		fprintf(stderr,"dependency %lu not found !\n", id);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		return;
 	}
 	t = j->bound_task;
@@ -376,14 +376,14 @@ void _starpu_bound_job_id_dep(starpu_data_handle_t handle, struct _starpu_job *j
 		t->deps[t->depsn-1].dep = dep_t;
 		t->deps[t->depsn-1].size = _starpu_data_get_size(handle);
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 void starpu_bound_stop(void)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	_starpu_bound_recording = 0;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /* Compute all tasks times on all workers */
@@ -462,7 +462,7 @@ void starpu_bound_print_lp(FILE *output)
 	int w, w2; /* worker */
 	unsigned n, n2;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	nw = starpu_worker_get_count();
 
 	if (recorddeps)
@@ -810,7 +810,7 @@ void starpu_bound_print_lp(FILE *output)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /*
@@ -829,7 +829,7 @@ void starpu_bound_print_mps(FILE *output)
 		return;
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	nw = starpu_worker_get_count();
 	nt = 0;
@@ -890,7 +890,7 @@ void starpu_bound_print_mps(FILE *output)
 		fprintf(output, "ENDATA\n");
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /*
@@ -1039,7 +1039,7 @@ void starpu_bound_print(FILE *output, int integer __attribute__ ((unused)))
 		return;
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	glp_prob *lp = _starpu_bound_glp_resolve(integer);
 	if (lp)
 	{
@@ -1074,7 +1074,7 @@ void starpu_bound_print(FILE *output, int integer __attribute__ ((unused)))
 	{
 		fprintf(stderr, "Simplex failed\n");
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 #else /* STARPU_HAVE_GLPK_H */
 	fprintf(output, "Please rebuild StarPU with glpk installed.\n");
 #endif /* STARPU_HAVE_GLPK_H */
@@ -1092,7 +1092,7 @@ void starpu_bound_compute(double *res, double *integer_res __attribute__ ((unuse
 		return;
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	glp_prob *lp = _starpu_bound_glp_resolve(integer);
 	if (lp)
 	{
@@ -1103,7 +1103,7 @@ void starpu_bound_compute(double *res, double *integer_res __attribute__ ((unuse
 	}
 	else
 		ret = 0.;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	*res = ret;
 #else /* STARPU_HAVE_GLPK_H */
 	*res = 0.;

src/profiling/profiling.c

@@ -102,7 +102,7 @@ void _starpu_profiling_init(void)
 	const char *env;
 	for (worker = 0; worker < STARPU_NMAXWORKERS; worker++)
 	{
-		_STARPU_PTHREAD_MUTEX_INIT(&worker_info_mutex[worker], NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&worker_info_mutex[worker], NULL);
 		_starpu_worker_reset_profiling_info(worker);
 	}
 	if ((env = getenv("STARPU_PROFILING")) && atoi(env))
@@ -184,9 +184,9 @@ static void _starpu_worker_reset_profiling_info_with_lock(int workerid)
 
 void _starpu_worker_reset_profiling_info(int workerid)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+	STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 	_starpu_worker_reset_profiling_info_with_lock(workerid);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 }
 
 void _starpu_worker_restart_sleeping(int workerid)
@@ -196,10 +196,10 @@ void _starpu_worker_restart_sleeping(int workerid)
 		struct timespec sleep_start_time;
 		_starpu_clock_gettime(&sleep_start_time);
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 		worker_registered_sleeping_start[workerid] = 1;
 		memcpy(&sleeping_start_date[workerid], &sleep_start_time, sizeof(struct timespec));
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 	}
 }
 
@@ -211,7 +211,7 @@ void _starpu_worker_stop_sleeping(int workerid)
 
 		_starpu_clock_gettime(&sleep_end_time);
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 
 		sleeping_start = &sleeping_start_date[workerid];
 
@@ -233,7 +233,7 @@ void _starpu_worker_stop_sleeping(int workerid)
 
 		worker_registered_sleeping_start[workerid] = 0;
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 
 	}
 }
@@ -242,10 +242,10 @@ void _starpu_worker_register_executing_start_date(int workerid, struct timespec
 {
 	if (starpu_profiling_status_get())
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 		worker_registered_executing_start[workerid] = 1;
 		memcpy(&executing_start_date[workerid], executing_start, sizeof(struct timespec));
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 	}
 }
 
@@ -254,7 +254,7 @@ void _starpu_worker_update_profiling_info_executing(int workerid, struct timespe
 {
 	if (starpu_profiling_status_get())
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 
 		if (executing_time)
 			starpu_timespec_accumulate(&worker_info[workerid].executing_time, executing_time);
@@ -264,7 +264,7 @@ void _starpu_worker_update_profiling_info_executing(int workerid, struct timespe
 		worker_info[workerid].power_consumed += power_consumed;
 		worker_info[workerid].executed_tasks += executed_tasks;
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 	}
 	else /* Not thread safe, shouldn't be too much a problem */
 		worker_info[workerid].executed_tasks += executed_tasks;
@@ -278,7 +278,7 @@ int starpu_worker_get_profiling_info(int workerid, struct starpu_worker_profilin
 		info->executed_tasks = worker_info[workerid].executed_tasks;
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
+	STARPU_PTHREAD_MUTEX_LOCK(&worker_info_mutex[workerid]);
 
 	if (info)
 	{
@@ -311,7 +311,7 @@ int starpu_worker_get_profiling_info(int workerid, struct starpu_worker_profilin
 
 	_starpu_worker_reset_profiling_info_with_lock(workerid);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&worker_info_mutex[workerid]);
 
 	return 0;
 }

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -20,14 +20,13 @@
 /* Distributed queues using performance modeling to assign tasks */
 
 #include <starpu_config.h>
-#include <limits.h>
+#include <starpu_scheduler.h>
+
+#include <common/fxt.h>
+#include <core/task.h>
 
-#include <core/perfmodel/perfmodel.h>
-#include <core/task_bundle.h>
-#include <core/workers.h>
 #include <sched_policies/fifo_queues.h>
-#include <core/perfmodel/perfmodel.h>
-#include <core/debug.h>
+#include <limits.h>
 
 #ifndef DBL_MIN
 #define DBL_MIN __DBL_MIN__
@@ -249,9 +248,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_mutex);
 	new_list = _starpu_fifo_pop_every_task(fifo, workerid);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	while (new_list)
 	{
 		double model = new_list->predicted;
@@ -286,7 +285,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_mutex);
 
         /* Sometimes workers didn't take the tasks as early as we expected */
 	fifo->exp_start = STARPU_MAX(fifo->exp_start, starpu_timing_now());
@@ -317,7 +316,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		fifo->exp_len += predicted;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	task->predicted = predicted;
 	task->predicted_transfer = predicted_transfer;
@@ -344,19 +343,19 @@ 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_mutex);
 		ret =_starpu_fifo_push_sorted_task(dt->queue_array[best_workerid], task);
-		_STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+		STARPU_PTHREAD_COND_SIGNAL(sched_cond);
 		starpu_push_task_end(task);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 		ret = _starpu_fifo_push_task(dt->queue_array[best_workerid], task);
-		_STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+		STARPU_PTHREAD_COND_SIGNAL(sched_cond);
 		starpu_push_task_end(task);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 
 	return ret;
@@ -400,10 +399,10 @@ static int _dm_push_task(struct starpu_task *task, unsigned prio, unsigned sched
 		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_mutex);
 		fifo->exp_start = STARPU_MAX(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_mutex);
 
 
 		for (nimpl = 0; nimpl < STARPU_MAXIMPLEMENTATIONS; nimpl++)
@@ -495,7 +494,7 @@ static int _dm_push_task(struct starpu_task *task, unsigned prio, unsigned sched
 
 	//_STARPU_DEBUG("Scheduler dm: kernel (%u)\n", best_impl);
 
-	_starpu_get_job_associated_to_task(task)->nimpl = best_impl;
+	starpu_task_set_implementation(task, best_impl);
 
 	/* we should now have the best worker in variable "best" */
 	return push_task_on_best_worker(task, best,
@@ -545,9 +544,9 @@ static void compute_all_performance_predictions(struct starpu_task *task,
 		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_mutex);
 		fifo->exp_start = STARPU_MAX(fifo->exp_start, starpu_timing_now());
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 		for(nimpl  = 0; nimpl < STARPU_MAXIMPLEMENTATIONS; nimpl++)
 	 	{
@@ -767,7 +766,7 @@ static int _dmda_push_task(struct starpu_task *task, unsigned prio, unsigned sch
 	}
 
 	//_STARPU_DEBUG("Scheduler dmda: kernel (%u)\n", best_impl);
-	 _starpu_get_job_associated_to_task(task)->nimpl = selected_impl;
+	starpu_task_set_implementation(task, selected_impl);
 
 	/* we should now have the best worker in variable "best" */
 	return push_task_on_best_worker(task, best, model_best, transfer_model_best, prio, sched_ctx_id);
@@ -909,14 +908,14 @@ 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_mutex);
 	if(!isnan(transfer_model))
 	{
 		fifo->exp_len-= transfer_model;
 		fifo->exp_start = starpu_timing_now() + model;
 		fifo->exp_end= fifo->exp_start + fifo->exp_len;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 }
 
 static void dmda_push_task_notify(struct starpu_task *task, int workerid, unsigned sched_ctx_id)
@@ -928,7 +927,7 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, unsign
 	unsigned memory_node = starpu_worker_get_memory_node(workerid);
 
 	double predicted = starpu_task_expected_length(task, perf_arch,
-			_starpu_get_job_associated_to_task(task)->nimpl);
+						       starpu_task_get_implementation(task));
 
 	double predicted_transfer = starpu_task_expected_data_transfer_time(memory_node, task);
 	starpu_pthread_mutex_t *sched_mutex;
@@ -937,7 +936,7 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, unsign
 
 
 	/* Update the predictions */
-	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 	/* Sometimes workers didn't take the tasks as early as we expected */
 	fifo->exp_start = STARPU_MAX(fifo->exp_start, starpu_timing_now());
 	fifo->exp_end = fifo->exp_start + fifo->exp_len;
@@ -972,7 +971,7 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, unsign
 
 	fifo->ntasks++;
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 }
 
 /* TODO: use post_exec_hook to fix the expected start */

src/sched_policies/deque_queues.c

@@ -92,7 +92,7 @@ struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq
 	struct _starpu_job_list *new_list, *old_list;
 
 	/* block until some task is available in that queue */
-	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 
 	if (deque_queue->njobs == 0)
 	{
@@ -141,7 +141,7 @@ struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	return new_list;
 }

src/sched_policies/eager_central_policy.c

@@ -43,7 +43,7 @@ static void initialize_eager_center_policy(unsigned sched_ctx_id)
 	data->fifo =  _starpu_create_fifo();
 
 	starpu_sched_ctx_set_policy_data(sched_ctx_id, (void*)data);
-	_STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
 }
 
 static void deinitialize_eager_center_policy(unsigned sched_ctx_id)
@@ -56,7 +56,7 @@ static void deinitialize_eager_center_policy(unsigned sched_ctx_id)
 	_starpu_destroy_fifo(data->fifo);
 
 	starpu_sched_ctx_delete_worker_collection(sched_ctx_id);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
 	free(data);
 }
 
@@ -66,11 +66,11 @@ static int push_task_eager_policy(struct starpu_task *task)
 	struct _starpu_eager_center_policy_data *data = (struct _starpu_eager_center_policy_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
 	int ret_val = -1;
 		
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 	ret_val = _starpu_fifo_push_task(data->fifo, task);
 
 	starpu_push_task_end(task);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
 	/*if there are no tasks block */
 	/* wake people waiting for a task */
@@ -87,9 +87,9 @@ static int push_task_eager_policy(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_COND_SIGNAL(sched_cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 
 	return ret_val;
@@ -100,9 +100,9 @@ static struct starpu_task *pop_every_task_eager_policy(unsigned sched_ctx_id)
 	struct _starpu_eager_center_policy_data *data = (struct _starpu_eager_center_policy_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
 	int workerid = starpu_worker_get_id();
 	
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 	struct starpu_task* task = _starpu_fifo_pop_every_task(data->fifo, workerid);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 	return task;
 }
 
@@ -127,10 +127,10 @@ static struct starpu_task *pop_task_eager_policy(unsigned sched_ctx_id)
 	VALGRIND_HG_MUTEX_UNLOCK_PRE(&data->policy_mutex);
 	VALGRIND_HG_MUTEX_UNLOCK_POST(&data->policy_mutex);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 	 task = _starpu_fifo_pop_task(data->fifo, workerid);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
-		
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+
 	return task;
 }
 

src/sched_policies/eager_central_priority_policy.c

@@ -23,9 +23,8 @@
 
 #include <starpu.h>
 #include <starpu_scheduler.h>
-#include <common/config.h>
-#include <core/workers.h>
-#include <common/utils.h>
+
+#include <common/fxt.h>
 
 #define MIN_LEVEL	(-5)
 #define MAX_LEVEL	(+5)
@@ -86,7 +85,7 @@ static void initialize_eager_center_priority_policy(unsigned sched_ctx_id)
 	/* only a single queue (even though there are several internaly) */
 	data->taskq = _starpu_create_priority_taskq();
 	starpu_sched_ctx_set_policy_data(sched_ctx_id, (void*)data);
-	_STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
 
 }
 
@@ -99,7 +98,7 @@ static void deinitialize_eager_center_priority_policy(unsigned sched_ctx_id)
 	_starpu_destroy_priority_taskq(data->taskq);
 
 	starpu_sched_ctx_delete_worker_collection(sched_ctx_id);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
 	free(data);
 }
 
@@ -109,17 +108,16 @@ static int _starpu_priority_push_task(struct starpu_task *task)
 	struct _starpu_eager_central_prio_data *data = (struct _starpu_eager_central_prio_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
 
 	struct _starpu_priority_taskq *taskq = data->taskq;
-	int ret_val = -1;
 	
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 	unsigned priolevel = task->priority - STARPU_MIN_PRIO;
 	
 	starpu_task_list_push_back(&taskq->taskq[priolevel], task);
 	taskq->ntasks[priolevel]++;
 	taskq->total_ntasks++;
 	starpu_push_task_end(task);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
 	/*if there are no tasks block */
 	/* wake people waiting for a task */
@@ -136,9 +134,9 @@ static int _starpu_priority_push_task(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_COND_SIGNAL(sched_cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 
 	return 0;
@@ -172,11 +170,11 @@ 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(curr_sched_mutex);
 	
 	/* all workers will block on this mutex anyway so 
 	   there's no need for their own mutex to be locked */
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 
 	unsigned priolevel = NPRIO_LEVELS - 1;
 	do
@@ -193,7 +191,7 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 					if (starpu_worker_can_execute_task(workerid, task, nimpl))
 					{
 						/* there is some task that we can grab */
-						_starpu_get_job_associated_to_task(task)->nimpl = nimpl;
+						starpu_task_set_implementation(task, nimpl);
 						starpu_task_list_erase(&taskq->taskq[priolevel], task);
 						chosen_task = task;
 						taskq->ntasks[priolevel]--;
@@ -225,18 +223,18 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 				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_COND_SIGNAL(sched_cond);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+				STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+				STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 			}
 		}
 	
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
-	/* leave the mutex how it was found before this */	
-	_STARPU_PTHREAD_MUTEX_LOCK(curr_sched_mutex);
+	/* leave the mutex how it was found before this */
+	STARPU_PTHREAD_MUTEX_LOCK(curr_sched_mutex);
 
 	return chosen_task;
 }

src/sched_policies/fifo_queues.c

@@ -18,11 +18,10 @@
 
 /* FIFO queues, ready for use by schedulers */
 
+#include <starpu_scheduler.h>
+
 #include <sched_policies/fifo_queues.h>
-#include <errno.h>
-#include <common/utils.h>
-#include <core/task.h>
-#include <core/workers.h>
+#include <common/fxt.h>
 
 struct _starpu_fifo_taskq *_starpu_create_fifo(void)
 {
@@ -145,7 +144,7 @@ struct starpu_task *_starpu_fifo_pop_task(struct _starpu_fifo_taskq *fifo_queue,
 		for (nimpl = 0; nimpl < STARPU_MAXIMPLEMENTATIONS; nimpl++)
 			if (starpu_worker_can_execute_task(workerid, task, nimpl))
 			{
-				_starpu_get_job_associated_to_task(task)->nimpl = nimpl;
+				starpu_task_set_implementation(task, nimpl);
 				starpu_task_list_erase(&fifo_queue->taskq, task);
 				fifo_queue->ntasks--;
 				_STARPU_TRACE_JOB_POP(task, 0);
@@ -220,7 +219,7 @@ struct starpu_task *_starpu_fifo_pop_every_task(struct _starpu_fifo_taskq *fifo_
 					task->prev = NULL;
 					task->next = NULL;
 				}
-				_starpu_get_job_associated_to_task(task)->nimpl = nimpl;
+				starpu_task_set_implementation(task, nimpl);
 				break;
 			}
 

src/sched_policies/parallel_eager.c

@@ -135,7 +135,7 @@ static void initialize_peager_policy(unsigned sched_ctx_id)
 	data->fifo = _starpu_create_fifo();
 
 	starpu_sched_ctx_set_policy_data(sched_ctx_id, (void*)data);
-        _STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
+        STARPU_PTHREAD_MUTEX_INIT(&data->policy_mutex, NULL);
 }
 
 static void deinitialize_peager_policy(unsigned sched_ctx_id)
@@ -147,7 +147,7 @@ static void deinitialize_peager_policy(unsigned sched_ctx_id)
 	_starpu_destroy_fifo(data->fifo);
 
 	starpu_sched_ctx_delete_worker_collection(sched_ctx_id);
-        _STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
+        STARPU_PTHREAD_MUTEX_DESTROY(&data->policy_mutex);
 
 	free(data);
 }
@@ -159,10 +159,10 @@ static int push_task_peager_policy(struct starpu_task *task)
 	
 	struct _starpu_peager_data *data = (struct _starpu_peager_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
 	
-	_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 	ret_val = _starpu_fifo_push_task(data->fifo, task);
 	starpu_push_task_end(task);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
         /*if there are no tasks block */
         /* wake people waiting for a task */
@@ -184,9 +184,9 @@ static int push_task_peager_policy(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_COND_SIGNAL(sched_cond);
-			_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+			STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+			STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+			STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 		}
 	}
 
@@ -203,9 +203,9 @@ static struct starpu_task *pop_task_peager_policy(unsigned sched_ctx_id)
 	if (starpu_worker_get_type(workerid) != STARPU_CPU_WORKER)
 	{
 		struct starpu_task *task = NULL;
-		_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 		task = _starpu_fifo_pop_task(data->fifo, workerid);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
 		return task;
 	}
@@ -216,9 +216,9 @@ static struct starpu_task *pop_task_peager_policy(unsigned sched_ctx_id)
 	{
 		/* The worker is a master */
 		struct starpu_task *task = NULL;
-		_STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&data->policy_mutex);
 		task = _starpu_fifo_pop_task(data->fifo, workerid);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&data->policy_mutex);
 
 		if (!task)
 			return NULL;
@@ -272,12 +272,12 @@ 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_mutex);
 
 				_starpu_fifo_push_task(data->local_fifo[local_worker], alias);
 
-				_STARPU_PTHREAD_COND_SIGNAL(sched_cond);
-				_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+				STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+				STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 			}
 

src/sched_policies/parallel_heft.c

@@ -83,12 +83,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_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_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)
@@ -116,21 +116,21 @@ 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_mutex);
 		worker_exp_len[best_workerid] += task->predicted;
 		worker_exp_end[best_workerid] = exp_end_predicted;
 		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_mutex);
 
 		/* We don't want it to interlace its task with a combined
 		 * worker's one */
-		_STARPU_PTHREAD_MUTEX_LOCK(&hd->global_push_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&hd->global_push_mutex);
 
 		ret = starpu_push_local_task(best_workerid, task, prio);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&hd->global_push_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&hd->global_push_mutex);
 	}
 	else
 	{
@@ -146,7 +146,7 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		starpu_combined_worker_get_description(best_workerid, &worker_size, &combined_workerid);
 
 		/* All cpu workers must be locked at once */
-		_STARPU_PTHREAD_MUTEX_LOCK(&hd->global_push_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&hd->global_push_mutex);
 
 		/* This is a combined worker so we create task aliases */
 		int i;
@@ -161,18 +161,18 @@ 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_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_mutex);
 
 			ret |= starpu_push_local_task(local_worker, alias, prio);
 		}
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&hd->global_push_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&hd->global_push_mutex);
 
 		//TODO : free task
 
@@ -323,12 +323,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_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_mutex);
 		}
 	}
 
@@ -575,7 +575,7 @@ static void initialize_parallel_heft_policy(unsigned sched_ctx_id)
 	if (strval_idle_power)
 		hd->idle_power = atof(strval_idle_power);
 
-	_STARPU_PTHREAD_MUTEX_INIT(&hd->global_push_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&hd->global_push_mutex, NULL);
 
 }
 
@@ -583,7 +583,7 @@ static void parallel_heft_deinit(unsigned sched_ctx_id)
 {
 	struct _starpu_pheft_data *hd = (struct _starpu_pheft_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
 	starpu_sched_ctx_delete_worker_collection(sched_ctx_id);
-	_STARPU_PTHREAD_MUTEX_DESTROY(&hd->global_push_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&hd->global_push_mutex);
 	free(hd);
 }
 

src/sched_policies/stack_queues.c

@@ -60,7 +60,7 @@ unsigned _starpu_get_stack_nprocessed(struct _starpu_stack_jobq *stack_queue)
 
 void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, starpu_pthread_mutex_t *sched_mutex, starpu_pthread_cond_t *sched_cond, struct _starpu_job *task)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 	total_number_of_jobs++;
 
 	if (task->task->priority)
@@ -70,8 +70,8 @@ void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, starpu_pthr
 	stack_queue->njobs++;
 	stack_queue->nprocessed++;
 
-	_STARPU_PTHREAD_COND_SIGNAL(sched_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 }
 
 struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queue, starpu_pthread_mutex_t *sched_mutex, int workerid __attribute__ ((unused)))
@@ -94,9 +94,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_mutex);
 		total_number_of_jobs--;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 
 	return j;

src/sched_policies/work_stealing_policy.c

@@ -283,7 +283,7 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 	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(worker_sched_mutex);
        
 
 	/* we need to steal someone's job */
@@ -293,7 +293,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(victim_sched_mutex);
 	struct _starpu_deque_jobq *victimq = ws->queue_array[victim];
 
 	task = _starpu_deque_pop_task(victimq, workerid);
@@ -308,9 +308,9 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 		victimq->njobs--;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(victim_sched_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(victim_sched_mutex);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(worker_sched_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(worker_sched_mutex);
 	if(!task)
 	{
 		task = _starpu_deque_pop_task(q, workerid);
@@ -348,7 +348,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(worker, &sched_mutex, &sched_cond);
-		_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 	}
 	
 	
@@ -377,8 +377,8 @@ 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(worker, &sched_mutex, &sched_cond);
-		_STARPU_PTHREAD_COND_SIGNAL(sched_cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
+		STARPU_PTHREAD_COND_SIGNAL(sched_cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 	}
 		
 	return 0;

src/top/starpu_top.c

@@ -137,7 +137,7 @@ void starpu_top_init_and_wait(const char* server_name)
 	_starpu_top=1;
 	sem_init(&starpu_top_wait_for_go,0,0);
 
-	_STARPU_PTHREAD_MUTEX_INIT(&starpu_top_wait_for_continue_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&starpu_top_wait_for_continue_mutex, NULL);
 
 	//profiling activation
 	starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
@@ -617,10 +617,10 @@ void starpu_top_debug_lock(const char* debug_message)
 		_starpu_top_message_add(_starpu_top_mt,message);
 
 		//This threads keeps locked while we don't receive an STEP message
-		_STARPU_PTHREAD_MUTEX_LOCK(&starpu_top_wait_for_continue_mutex);
-		_STARPU_PTHREAD_COND_WAIT(&starpu_top_wait_for_continue_cond,
+		STARPU_PTHREAD_MUTEX_LOCK(&starpu_top_wait_for_continue_mutex);
+		STARPU_PTHREAD_COND_WAIT(&starpu_top_wait_for_continue_cond,
 					  &starpu_top_wait_for_continue_mutex);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&starpu_top_wait_for_continue_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&starpu_top_wait_for_continue_mutex);
 	}
 }
 
@@ -742,7 +742,7 @@ void starpu_top_change_debug_mode(const char*message)
 static
 void starpu_top_debug_next_step(void)
 {
-	_STARPU_PTHREAD_COND_SIGNAL(&starpu_top_wait_for_continue_cond);
+	STARPU_PTHREAD_COND_SIGNAL(&starpu_top_wait_for_continue_cond);
 }
 
 

src/top/starpu_top_connection.c

@@ -161,7 +161,7 @@ void _starpu_top_communications_threads_launcher(void)
 	starpu_pthread_attr_init(&threads_attr);
 	starpu_pthread_attr_setdetachstate(&threads_attr, PTHREAD_CREATE_DETACHED);
 
-	_STARPU_PTHREAD_CREATE("StarPU-Top from", &from_ui, &threads_attr, message_from_ui, NULL);
-	_STARPU_PTHREAD_CREATE("StarPU-Top to", &to_ui, &threads_attr, message_to_ui, NULL);
+	STARPU_PTHREAD_CREATE(&from_ui, &threads_attr, message_from_ui, NULL);
+	STARPU_PTHREAD_CREATE(&to_ui, &threads_attr, message_to_ui, NULL);
 }
 

src/top/starpu_top_message_queue.c

@@ -30,11 +30,11 @@ struct _starpu_top_message_queue* _starpu_top_message_add(struct _starpu_top_mes
 							char* msg)
 {
 	struct _starpu_top_message_queue_item* p = (struct _starpu_top_message_queue_item *) malloc( 1 * sizeof(*p) );
-	_STARPU_PTHREAD_MUTEX_LOCK(&(s->mutex));
+	STARPU_PTHREAD_MUTEX_LOCK(&(s->mutex));
 	if( NULL == p )
 	{
 		fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "list_add");
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
+		STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
 		return s;
 	}
 
@@ -44,7 +44,7 @@ struct _starpu_top_message_queue* _starpu_top_message_add(struct _starpu_top_mes
 	if( NULL == s )
 	{
 		printf("Queue not initialized\n");
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
+		STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
 		return s;
 	}
 	else if( NULL == s->head && NULL == s->tail )
@@ -52,7 +52,7 @@ struct _starpu_top_message_queue* _starpu_top_message_add(struct _starpu_top_mes
 		/* printf("Empty list, adding p->num: %d\n\n", p->num);  */
 		sem_post(&(s->semaphore));
 		s->head = s->tail = p;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
+		STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
 		return s;
 	}
 	else
@@ -62,7 +62,7 @@ struct _starpu_top_message_queue* _starpu_top_message_add(struct _starpu_top_mes
 		s->tail->next = p;
 		s->tail = p;
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
+	STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
 	return s;
 }
 
@@ -78,7 +78,7 @@ char* _starpu_top_message_remove(struct _starpu_top_message_queue* s)
 		printf("List is null\n");
 		return NULL;
 	}
-	_STARPU_PTHREAD_MUTEX_LOCK(&(s->mutex));
+	STARPU_PTHREAD_MUTEX_LOCK(&(s->mutex));
 	h = s->head;
 	p = h->next;
 	char* value = h->message;
@@ -89,7 +89,7 @@ char* _starpu_top_message_remove(struct _starpu_top_message_queue* s)
 	if( NULL == s->head )
 		//the element tail was pointing to is free(), so we need an update
 		s->tail = s->head;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
+	STARPU_PTHREAD_MUTEX_UNLOCK(&(s->mutex));
 	return value;
 }
 
@@ -105,6 +105,6 @@ struct _starpu_top_message_queue* _starpu_top_message_queue_new(void)
 
 	p->head = p->tail = NULL;
 	sem_init(&(p->semaphore),0,0);
-	_STARPU_PTHREAD_MUTEX_INIT(&(p->mutex), NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&(p->mutex), NULL);
 	return p;
 }

tests/datawizard/dsm_stress.c

@@ -48,10 +48,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -221,10 +221,10 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(v_handle);
 	starpu_data_unregister(v_handle2);

tests/datawizard/mpi_like.c

@@ -100,22 +100,22 @@ static void increment_handle(struct thread_data *thread_data)
 static void recv_handle(struct thread_data *thread_data)
 {
 	starpu_data_acquire(thread_data->handle, STARPU_W);
-	_STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
 
 	/* We wait for the previous thread to notify that the data is available */
 	while (!thread_data->recv_flag)
-		_STARPU_PTHREAD_COND_WAIT(&thread_data->recv_cond, &thread_data->recv_mutex);
+		STARPU_PTHREAD_COND_WAIT(&thread_data->recv_cond, &thread_data->recv_mutex);
 
 	/* We overwrite thread's data with the received value */
 	thread_data->val = thread_data->recv_buf;
 
 	/* Notify that we read the value */
 	thread_data->recv_flag = 0;
-	_STARPU_PTHREAD_COND_SIGNAL(&thread_data->recv_cond);
+	STARPU_PTHREAD_COND_SIGNAL(&thread_data->recv_cond);
 
 //	FPRINTF(stderr, "Thread %d received value %d from thread %d\n", thread_data->index, thread_data->val, (thread_data->index - 1)%NTHREADS);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
 	starpu_data_release(thread_data->handle);
 }
 
@@ -127,16 +127,16 @@ static void send_handle(struct thread_data *thread_data)
 
 //	FPRINTF(stderr, "Thread %d sends value %d to thread %d\n", thread_data->index, thread_data->val, neighbour_data->index);
 	/* send the message */
-	_STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	neighbour_data->recv_buf = thread_data->val;
 	neighbour_data->recv_flag = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&neighbour_data->recv_cond);
+	STARPU_PTHREAD_COND_SIGNAL(&neighbour_data->recv_cond);
 
 	/* wait until it's received (ie. neighbour's recv_flag is set back to 0) */
 	while (neighbour_data->recv_flag)
-		_STARPU_PTHREAD_COND_WAIT(&neighbour_data->recv_cond, &neighbour_data->recv_mutex);
+		STARPU_PTHREAD_COND_WAIT(&neighbour_data->recv_cond, &neighbour_data->recv_mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
 
 	starpu_data_release(thread_data->handle);
 }
@@ -190,8 +190,8 @@ int main(int argc, char **argv)
 	{
 		problem_data[t].index = t;
 		problem_data[t].val = 0;
-		_STARPU_PTHREAD_COND_INIT(&problem_data[t].recv_cond, NULL);
-		_STARPU_PTHREAD_MUTEX_INIT(&problem_data[t].recv_mutex, NULL);
+		STARPU_PTHREAD_COND_INIT(&problem_data[t].recv_cond, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&problem_data[t].recv_mutex, NULL);
 		problem_data[t].recv_flag = 0;
 		problem_data[t].neighbour = &problem_data[(t+1)%NTHREADS];
 	}

tests/datawizard/mpi_like_async.c

@@ -120,7 +120,7 @@ static int test_recv_handle_async(void *arg)
 	int ret;
 	struct thread_data *thread_data = (struct thread_data *) arg;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
 
 	ret = (thread_data->recv_flag == 1);
 
@@ -130,7 +130,7 @@ static int test_recv_handle_async(void *arg)
 		thread_data->val = thread_data->recv_buf;
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
 
 	if (ret)
 	{
@@ -153,11 +153,11 @@ static void recv_handle_async(void *_thread_data)
 	req->test_arg = thread_data;
 	req->next = NULL;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	req->next = data_req_list;
 	data_req_list = req;
-	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 }
 
 static int test_send_handle_async(void *arg)
@@ -166,9 +166,9 @@ static int test_send_handle_async(void *arg)
 	struct thread_data *thread_data = (struct thread_data *) arg;
 	struct thread_data *neighbour_data = thread_data->neighbour;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	ret = (neighbour_data->recv_flag == 0);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
 
 	if (ret)
 	{
@@ -189,36 +189,36 @@ static void send_handle_async(void *_thread_data)
 //	FPRINTF(stderr, "send_handle_async\n");
 
 	/* send the message */
-	_STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	neighbour_data->recv_buf = thread_data->val;
 	neighbour_data->recv_flag = 1;
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
 
 	struct data_req *req = (struct data_req *) malloc(sizeof(struct data_req));
 	req->test_func = test_send_handle_async;
 	req->test_arg = thread_data;
 	req->next = NULL;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	req->next = data_req_list;
 	data_req_list = req;
-	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 }
 
 static void *progress_func(void *arg)
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 	progress_thread_running = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
+	STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
 
 	while (progress_thread_running)
 	{
 		struct data_req *req;
 
 		if (data_req_list == NULL)
-			_STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
+			STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
 
 		req = data_req_list;
 
@@ -227,19 +227,19 @@ static void *progress_func(void *arg)
 			data_req_list = req->next;
 			req->next = NULL;
 
-			_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 			int ret = req->test_func(req->test_arg);
 
 			if (ret)
 			{
 				free(req);
-				_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 			}
 			else
 			{
 				/* ret = 0 : the request is not finished, we put it back at the end of the list */
-				_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+				STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 				struct data_req *req_aux = data_req_list;
 				if (!req_aux)
@@ -263,7 +263,7 @@ static void *progress_func(void *arg)
 			}
 		}
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	return NULL;
 }
@@ -331,8 +331,8 @@ int main(int argc, char **argv)
 
 	/* Create a thread to perform blocking calls */
 	starpu_pthread_t progress_thread;
-	_STARPU_PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&data_req_cond, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&data_req_cond, NULL);
 	data_req_list = NULL;
 	progress_thread_running = 0;
 
@@ -341,17 +341,17 @@ int main(int argc, char **argv)
 	{
 		problem_data[t].index = t;
 		problem_data[t].val = 0;
-		_STARPU_PTHREAD_MUTEX_INIT(&problem_data[t].recv_mutex, NULL);
+		STARPU_PTHREAD_MUTEX_INIT(&problem_data[t].recv_mutex, NULL);
 		problem_data[t].recv_flag = 0;
 		problem_data[t].neighbour = &problem_data[(t+1)%nthreads];
 	}
 
 	starpu_pthread_create(&progress_thread, NULL, progress_func, NULL);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	while (!progress_thread_running)
-		_STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+		STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	for (t = 0; t < nthreads; t++)
 	{
@@ -366,10 +366,10 @@ int main(int argc, char **argv)
 		STARPU_ASSERT(retval == NULL);
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	progress_thread_running = 0;
-	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	ret = starpu_pthread_join(progress_thread, &retval);
 	STARPU_ASSERT(!ret);

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -71,14 +71,14 @@ static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == nbuffers)
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -121,9 +121,9 @@ int main(int argc, char **argv)
 		ret = starpu_task_wait_for_all();
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < nbuffers; b++)
@@ -134,12 +134,12 @@ int main(int argc, char **argv)
 		}
 
 		/* Wait for all buffers to be available */
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != nbuffers)
-			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
 		for (b = 0; b < nbuffers; b++)

tests/datawizard/sync_with_data_with_mem_non_blocking_implicit.c

@@ -71,14 +71,14 @@ static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == nbuffers)
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -117,9 +117,9 @@ int main(int argc, char **argv)
 			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 		}
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < nbuffers; b++)
@@ -130,12 +130,12 @@ int main(int argc, char **argv)
 		}
 
 		/* Wait for all buffers to be available */
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != nbuffers)
-			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
 		for (b = 0; b < nbuffers; b++)

tests/experiments/latency/cuda_latency.c

@@ -69,11 +69,11 @@ void send_data(unsigned src, unsigned dst)
 #endif
 
 	/* Tell the other GPU that data is in RAM */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
 	data_is_available[src] = 0;
 	data_is_available[dst] = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond_gpu);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
+	STARPU_PTHREAD_COND_SIGNAL(&cond_gpu);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
 	//fprintf(stderr, "SEND on %d\n", src);
 }
 
@@ -82,12 +82,12 @@ void recv_data(unsigned src, unsigned dst)
 	cudaError_t cures;
 
 	/* Wait for the data to be in RAM */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
 	while (!data_is_available[dst])
 	{
-		_STARPU_PTHREAD_COND_WAIT(&cond_gpu, &mutex_gpu);
+		STARPU_PTHREAD_COND_WAIT(&cond_gpu, &mutex_gpu);
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
 	//fprintf(stderr, "RECV on %d\n", dst);
 
 	/* Upload data */
@@ -118,9 +118,9 @@ void *launch_gpu_thread(void *arg)
 	cudaMalloc(&gpu_buffer[id], buffer_size);
 	cudaStreamCreate(&stream[id]);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	thread_is_initialized[id] = 1;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond);
+	STARPU_PTHREAD_COND_SIGNAL(&cond);
 
 	if (id == 0)
 	{
@@ -133,9 +133,9 @@ void *launch_gpu_thread(void *arg)
 	nready_gpu++;
 
 	while (!ready)
-		_STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	unsigned iter;
 	for (iter = 0; iter < niter; iter++)
@@ -152,10 +152,10 @@ void *launch_gpu_thread(void *arg)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	nready_gpu--;
-	_STARPU_PTHREAD_COND_SIGNAL(&cond_go);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_SIGNAL(&cond_go);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return NULL;
 }
@@ -163,9 +163,9 @@ void *launch_gpu_thread(void *arg)
 int main(int argc, char **argv)
 {
 
-	_STARPU_PTHREAD_MUTEX_INIT(&mutex, NULL);
-	_STARPU_PTHREAD_COND_INIT(&cond, NULL);
-	_STARPU_PTHREAD_COND_INIT(&cond_go, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&mutex, NULL);
+	STARPU_PTHREAD_COND_INIT(&cond, NULL);
+	STARPU_PTHREAD_COND_INIT(&cond_go, NULL);
 
 	unsigned id;
 	for (id = 0; id < 2; id++)
@@ -173,12 +173,12 @@ int main(int argc, char **argv)
 		thread_is_initialized[id] = 0;
 		starpu_pthread_create(&thread[0], NULL, launch_gpu_thread, &id);
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		while (!thread_is_initialized[id])
 		{
-			 _STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			 STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 		}
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 
 	struct timeval start;
@@ -187,18 +187,18 @@ int main(int argc, char **argv)
 	/* Start the ping pong */
 	gettimeofday(&start, NULL);
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	ready = 1;
-	_STARPU_PTHREAD_COND_BROADCAST(&cond_go);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_COND_BROADCAST(&cond_go);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	/* Wait for the end of the ping pong */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (nready_gpu > 0)
 	{
-		_STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
 	}
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	gettimeofday(&end, NULL);
 	

tests/main/execute_on_a_specific_worker.c

@@ -47,10 +47,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -145,10 +145,10 @@ int main(int argc, char **argv)
 		}
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (!finished)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(v_handle);
 	starpu_free(v);

tests/main/regenerate.c

@@ -44,10 +44,10 @@ static void callback(void *arg __attribute__ ((unused)))
 		task->regenerate = 0;
 		FPRINTF(stderr, "Stop !\n");
 
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		completed = 1;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -108,10 +108,10 @@ int main(int argc, char **argv)
 	if (ret == -ENODEV) goto enodev;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!completed)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	gettimeofday(&end, NULL);
 

tests/main/subgraph_repeat.c

@@ -65,19 +65,19 @@ static struct starpu_codelet dummy_codelet =
 
 static void callback_task_D(void *arg __attribute__((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	loop_cnt++;
 
 	if (loop_cnt == niter)
 	{
 		/* We are done */
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else
 	{
 		int ret;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		/* Let's go for another iteration */
 		ret = starpu_task_submit(&taskA); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 		ret = starpu_task_submit(&taskB); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
@@ -128,10 +128,10 @@ int main(int argc, char **argv)
 	ret = starpu_task_submit(&taskD); if (ret == -ENODEV) goto enodev; STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 
 	/* Wait for the termination of all loops */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/main/subgraph_repeat_regenerate.c

@@ -65,20 +65,20 @@ static struct starpu_codelet dummy_codelet =
 
 static void callback_task_D(void *arg __attribute__((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	loop_cnt++;
 
 	if (loop_cnt == niter)
 	{
 		/* We are done */
 		taskD.regenerate = 0;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else
 	{
 		int ret;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		/* Let's go for another iteration */
 		ret = starpu_task_submit(&taskA);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
@@ -134,10 +134,10 @@ int main(int argc, char **argv)
 	ret = starpu_task_submit(&taskD); if (ret == -ENODEV) goto enodev; STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 
 	/* Wait for the termination of all loops */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/main/subgraph_repeat_regenerate_tag.c

@@ -71,19 +71,19 @@ static struct starpu_codelet dummy_codelet =
 
 static void callback_task_D(void *arg __attribute__((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	loop_cnt++;
 
 	if (loop_cnt == niter)
 	{
 		/* We are done */
 		taskD.regenerate = 0;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else
 	{
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		/* Let's go for another iteration */
 		starpu_tag_restart((starpu_tag_t) TAG_START);
 		starpu_tag_notify_from_apps((starpu_tag_t)TAG_START);
@@ -149,10 +149,10 @@ int main(int argc, char **argv)
 	starpu_tag_notify_from_apps((starpu_tag_t) TAG_START);
 
 	/* Wait for the termination of all loops */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/main/subgraph_repeat_tag.c

@@ -64,20 +64,20 @@ static struct starpu_codelet dummy_codelet =
 
 static void callback_task_D(void *arg __attribute__((unused)))
 {
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	loop_cnt++;
 
 	if (loop_cnt == niter)
 	{
 		/* We are done */
 		taskD.regenerate = 0;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else
 	{
 		int ret;
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		/* Let's go for another iteration */
 		ret = starpu_task_submit(&taskA);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
@@ -133,10 +133,10 @@ int main(int argc, char **argv)
 	ret = starpu_task_submit(&taskD); if (ret == -ENODEV) goto enodev; STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 
 	/* Wait for the termination of all loops */
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/overlap/overlap.c

@@ -47,10 +47,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		_STARPU_PTHREAD_COND_SIGNAL(&cond);
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_SIGNAL(&cond);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -124,10 +124,10 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
+		STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unpartition(handle, 0);
 	starpu_data_unregister(handle);

tools/dev/internal/rename_internal.sed

@@ -207,24 +207,24 @@ s/\bSTARPU_TRACE_WORK_STEALING\b/_STARPU_TRACE_WORK_STEALING/g
 #s/\bstarpu_worker_status\b/enum _starpu_worker_status/g
 #s/\bstarpu_worker_s\b/_starpu_worker/g
 #
-#s/\bPTHREAD_MUTEX_INIT\b/_STARPU_PTHREAD_MUTEX_INIT/g
-#s/\bPTHREAD_MUTEX_DESTROY\b/_STARPU_PTHREAD_MUTEX_DESTROY/g
-#s/\bPTHREAD_MUTEX_LOCK\b/_STARPU_PTHREAD_MUTEX_LOCK/g
-#s/\bPTHREAD_MUTEX_UNLOCK\b/_STARPU_PTHREAD_MUTEX_UNLOCK/g
-#
-#s/\bPTHREAD_RWLOCK_INIT\b/_STARPU_PTHREAD_RWLOCK_INIT/g
-#s/\bPTHREAD_RWLOCK_RDLOCK\b/_STARPU_PTHREAD_RWLOCK_RDLOCK/g
-#s/\bPTHREAD_RWLOCK_WRLOCK\b/_STARPU_PTHREAD_RWLOCK_WRLOCK/g
-#s/\bPTHREAD_RWLOCK_UNLOCK\b/_STARPU_PTHREAD_RWLOCK_UNLOCK/g
-#s/\bPTHREAD_RWLOCK_DESTROY\b/_STARPU_PTHREAD_RWLOCK_DESTROY/g
-#
-#s/\bPTHREAD_COND_INIT\b/_STARPU_PTHREAD_COND_INIT/g
-#s/\bPTHREAD_COND_DESTROY\b/_STARPU_PTHREAD_COND_DESTROY/g
-#s/\bPTHREAD_COND_SIGNAL\b/_STARPU_PTHREAD_COND_SIGNAL/g
-#s/\bPTHREAD_COND_BROADCAST\b/_STARPU_PTHREAD_COND_BROADCAST/g
-#s/\bPTHREAD_COND_WAIT\b/_STARPU_PTHREAD_COND_WAIT/g
-#
-#s/\bPTHREAD_BARRIER_INIT\b/_STARPU_PTHREAD_BARRIER_INIT/g
-#s/\bPTHREAD_BARRIER_DESTROY\b/_STARPU_PTHREAD_BARRIER_DESTROY/g
-#s/\bPTHREAD_BARRIER_WAIT\b/_STARPU_PTHREAD_BARRIER_WAIT/g
+#s/\bPTHREAD_MUTEX_INIT\b/STARPU_PTHREAD_MUTEX_INIT/g
+#s/\bPTHREAD_MUTEX_DESTROY\b/STARPU_PTHREAD_MUTEX_DESTROY/g
+#s/\bPTHREAD_MUTEX_LOCK\b/STARPU_PTHREAD_MUTEX_LOCK/g
+#s/\bPTHREAD_MUTEX_UNLOCK\b/STARPU_PTHREAD_MUTEX_UNLOCK/g
+#
+#s/\bPTHREAD_RWLOCK_INIT\b/STARPU_PTHREAD_RWLOCK_INIT/g
+#s/\bPTHREAD_RWLOCK_RDLOCK\b/STARPU_PTHREAD_RWLOCK_RDLOCK/g
+#s/\bPTHREAD_RWLOCK_WRLOCK\b/STARPU_PTHREAD_RWLOCK_WRLOCK/g
+#s/\bPTHREAD_RWLOCK_UNLOCK\b/STARPU_PTHREAD_RWLOCK_UNLOCK/g
+#s/\bPTHREAD_RWLOCK_DESTROY\b/STARPU_PTHREAD_RWLOCK_DESTROY/g
+#
+#s/\bPTHREAD_COND_INIT\b/STARPU_PTHREAD_COND_INIT/g
+#s/\bPTHREAD_COND_DESTROY\b/STARPU_PTHREAD_COND_DESTROY/g
+#s/\bPTHREAD_COND_SIGNAL\b/STARPU_PTHREAD_COND_SIGNAL/g
+#s/\bPTHREAD_COND_BROADCAST\b/STARPU_PTHREAD_COND_BROADCAST/g
+#s/\bPTHREAD_COND_WAIT\b/STARPU_PTHREAD_COND_WAIT/g
+#
+#s/\bPTHREAD_BARRIER_INIT\b/STARPU_PTHREAD_BARRIER_INIT/g
+#s/\bPTHREAD_BARRIER_DESTROY\b/STARPU_PTHREAD_BARRIER_DESTROY/g
+#s/\bPTHREAD_BARRIER_WAIT\b/STARPU_PTHREAD_BARRIER_WAIT/g