mpi/tests: tests/ prefix names of internal types and functions with _starpu

mpi/starpu_mpi.c

@@ -45,7 +45,7 @@ static int running = 0;
 static pthread_mutex_t mutex_posted_requests;
 static int posted_requests = 0;
 
-#define INC_POSTED_REQUESTS(value) { PTHREAD_MUTEX_LOCK(&mutex_posted_requests); posted_requests += value; PTHREAD_MUTEX_UNLOCK(&mutex_posted_requests); }
+#define INC_POSTED_REQUESTS(value) { _STARPU_PTHREAD_MUTEX_LOCK(&mutex_posted_requests); posted_requests += value; _STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_posted_requests); }
 
 /*
  *	Isend
@@ -66,10 +66,10 @@ static void starpu_mpi_isend_func(struct starpu_mpi_req_s *req)
 	TRACE_MPI_ISEND(req->srcdst, req->mpi_tag, 0);
 
 	/* somebody is perhaps waiting for the MPI request to be posted */
-	PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	PTHREAD_COND_BROADCAST(&req->req_cond);
-	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
         _STARPU_MPI_LOG_OUT();
 }
 
@@ -87,8 +87,8 @@ static struct starpu_mpi_req_s *_starpu_mpi_isend_common(starpu_data_handle data
 	/* Initialize the request structure */
 	req->submitted = 0;
 	req->completed = 0;
-	PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
-	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 = SEND_REQ;
 
@@ -158,10 +158,10 @@ static void starpu_mpi_irecv_func(struct starpu_mpi_req_s *req)
         STARPU_ASSERT(req->ret == MPI_SUCCESS);
 
 	/* somebody is perhaps waiting for the MPI request to be posted */
-	PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	PTHREAD_COND_BROADCAST(&req->req_cond);
-	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
         _STARPU_MPI_LOG_OUT();
 }
 
@@ -175,8 +175,8 @@ static struct starpu_mpi_req_s *_starpu_mpi_irecv_common(starpu_data_handle data
 
 	/* Initialize the request structure */
 	req->submitted = 0;
-	PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
-	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 = RECV_REQ;
 
@@ -293,14 +293,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. */
-	PTHREAD_MUTEX_LOCK(&(req->req_mutex));
+	_STARPU_PTHREAD_MUTEX_LOCK(&(req->req_mutex));
 	while (!(req->submitted))
-		PTHREAD_COND_WAIT(&(req->req_cond), &(req->req_mutex));
-	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 */
-	PTHREAD_MUTEX_INIT(&(waiting_req->req_mutex), NULL);
-	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;
@@ -309,10 +309,10 @@ int starpu_mpi_wait(starpu_mpi_req *public_req, MPI_Status *status)
 	submit_mpi_req(waiting_req);
 
 	/* We wait for the MPI request to finish */
-	PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	while (!req->completed)
-		PTHREAD_COND_WAIT(&req->req_cond, &req->req_mutex);
-	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;
 
@@ -345,10 +345,10 @@ static void starpu_mpi_test_func(struct starpu_mpi_req_s *testing_req)
 		handle_request_termination(req);
 	}
 
-	PTHREAD_MUTEX_LOCK(&testing_req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&testing_req->req_mutex);
 	testing_req->completed = 1;
-	PTHREAD_COND_SIGNAL(&testing_req->req_cond);
-	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();
 }
 
@@ -363,9 +363,9 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
 
 	STARPU_ASSERT(!req->detached);
 
-	PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	unsigned submitted = req->submitted;
-	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	if (submitted)
 	{
@@ -374,8 +374,8 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
                 //		memset(testing_req, 0, sizeof(struct starpu_mpi_req_s));
 
 		/* Initialize the request structure */
-		PTHREAD_MUTEX_INIT(&(testing_req->req_mutex), NULL);
-		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;
@@ -387,10 +387,10 @@ int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
                 submit_mpi_req(testing_req);
 
 		/* We wait for the test request to finish */
-		PTHREAD_MUTEX_LOCK(&(testing_req->req_mutex));
+		_STARPU_PTHREAD_MUTEX_LOCK(&(testing_req->req_mutex));
 		while (!(testing_req->completed))
-                        PTHREAD_COND_WAIT(&(testing_req->req_cond), &(testing_req->req_mutex));
-		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;
 
@@ -434,8 +434,8 @@ int starpu_mpi_barrier(MPI_Comm comm)
 	STARPU_ASSERT(barrier_req);
 
 	/* Initialize the request structure */
-	PTHREAD_MUTEX_INIT(&(barrier_req->req_mutex), NULL);
-	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;
@@ -444,10 +444,10 @@ int starpu_mpi_barrier(MPI_Comm comm)
 	submit_mpi_req(barrier_req);
 
 	/* We wait for the MPI request to finish */
-	PTHREAD_MUTEX_LOCK(&barrier_req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier_req->req_mutex);
 	while (!barrier_req->completed)
-		PTHREAD_COND_WAIT(&barrier_req->req_cond, &barrier_req->req_mutex);
-	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;
 
@@ -497,10 +497,10 @@ static void handle_request_termination(struct starpu_mpi_req_s *req)
 
 	/* tell anyone potentiallly waiting on the request that it is
 	 * terminated now */
-	PTHREAD_MUTEX_LOCK(&req->req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->completed = 1;
-	PTHREAD_COND_BROADCAST(&req->req_cond);
-	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&req->req_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
         _STARPU_MPI_LOG_OUT();
 }
 
@@ -511,11 +511,11 @@ static void submit_mpi_req(void *arg)
 
         INC_POSTED_REQUESTS(-1);
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	starpu_mpi_req_list_push_front(new_requests, req);
         _STARPU_MPI_DEBUG("Pushing new request type %d\n", req->request_type);
-	PTHREAD_COND_BROADCAST(&cond);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
         _STARPU_MPI_LOG_OUT();
 }
 
@@ -528,13 +528,13 @@ static unsigned progression_hook_func(void *arg __attribute__((unused)))
 {
 	unsigned may_block = 1;
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!starpu_mpi_req_list_empty(detached_requests))
 	{
-		PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
 		may_block = 0;
 	}
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return may_block;
 }
@@ -551,7 +551,7 @@ static void test_detached_requests(void)
 	MPI_Status status;
 	struct starpu_mpi_req_s *req, *next_req;
 
-	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);
@@ -559,7 +559,7 @@ static void test_detached_requests(void)
 	{
 		next_req = starpu_mpi_req_list_next(req);
 
-		PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
 
                 //_STARPU_MPI_DEBUG("Test detached request %p - mpitag %d - TYPE %s %d\n", &req->request, req->mpi_tag, (req->request_type == RECV_REQ)?"recv : source":"send : dest", req->srcdst);
 		req->ret = MPI_Test(&req->request, &flag, &status);
@@ -570,7 +570,7 @@ static void test_detached_requests(void)
 			handle_request_termination(req);
 		}
 
-		PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
 
 		if (flag)
 			starpu_mpi_req_list_erase(detached_requests, req);
@@ -583,7 +583,7 @@ static void test_detached_requests(void)
 		//	free(req);
 	}
 
-	PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
         _STARPU_MPI_LOG_OUT();
 }
 
@@ -598,17 +598,17 @@ static void handle_new_request(struct starpu_mpi_req_s *req)
 
 	if (req->detached)
 	{
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		starpu_mpi_req_list_push_front(detached_requests, req);
-		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 */
-		PTHREAD_MUTEX_LOCK(&mutex);
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
         _STARPU_MPI_LOG_OUT();
 }
@@ -638,12 +638,12 @@ static void *progress_thread_func(void *arg)
         }
 
 	/* notify the main thread that the progression thread is ready */
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	running = 1;
-	PTHREAD_COND_SIGNAL(&cond);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (running || posted_requests || !(starpu_mpi_req_list_empty(new_requests)) || !(starpu_mpi_req_list_empty(detached_requests))) {
 		/* shall we block ? */
 		unsigned block = starpu_mpi_req_list_empty(new_requests);
@@ -655,13 +655,13 @@ static void *progress_thread_func(void *arg)
 		if (block)
 		{
                         _STARPU_MPI_DEBUG("NO MORE REQUESTS TO HANDLE\n");
-			PTHREAD_COND_WAIT(&cond, &mutex);
+			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 		}
 
 		/* test whether there are some terminated "detached request" */
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		test_detached_requests();
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		/* get one request */
 		struct starpu_mpi_req_s *req;
@@ -673,9 +673,9 @@ static void *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.  */
-			PTHREAD_MUTEX_UNLOCK(&mutex);
+			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 			handle_new_request(req);
-			PTHREAD_MUTEX_LOCK(&mutex);
+			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		}
 	}
 
@@ -688,7 +688,7 @@ static void *progress_thread_func(void *arg)
                 MPI_Finalize();
         }
 
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return NULL;
 }
@@ -735,21 +735,21 @@ static void _starpu_mpi_add_sync_point_in_fxt(void)
 static
 int _starpu_mpi_initialize(int initialize_mpi, int *rank, int *world_size)
 {
-	PTHREAD_MUTEX_INIT(&mutex, NULL);
-	PTHREAD_COND_INIT(&cond, NULL);
+	_STARPU_PTHREAD_MUTEX_INIT(&mutex, NULL);
+	_STARPU_PTHREAD_COND_INIT(&cond, NULL);
 	new_requests = starpu_mpi_req_list_new();
 
-	PTHREAD_MUTEX_INIT(&detached_requests_mutex, NULL);
+	_STARPU_PTHREAD_MUTEX_INIT(&detached_requests_mutex, NULL);
 	detached_requests = starpu_mpi_req_list_new();
 
-        PTHREAD_MUTEX_INIT(&mutex_posted_requests, NULL);
+        _STARPU_PTHREAD_MUTEX_INIT(&mutex_posted_requests, NULL);
 
 	pthread_create(&progress_thread, NULL, progress_thread_func, (void *)&initialize_mpi);
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (!running)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
         if (rank && world_size) {
                 _STARPU_DEBUG("Calling MPI_Comm_rank\n");
@@ -788,10 +788,10 @@ int starpu_mpi_shutdown(void)
 	void *value;
 
 	/* kill the progression thread */
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	running = 0;
-	PTHREAD_COND_BROADCAST(&cond);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	pthread_join(progress_thread, &value);
 

mpi/tests/mpi_irecv_detached.c

@@ -31,10 +31,10 @@ void callback(void *arg __attribute__((unused)))
 {
 	unsigned *received = arg;
 	
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	*received = 1;
-	PTHREAD_COND_SIGNAL(&cond);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 
@@ -78,10 +78,10 @@ int main(int argc, char **argv)
 			int received = 0;
 			starpu_mpi_irecv_detached(tab_handle, other_rank, loop, MPI_COMM_WORLD, callback, &received);
 
-			PTHREAD_MUTEX_LOCK(&mutex);
+			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 			while (!received)
-				PTHREAD_COND_WAIT(&cond, &mutex);
-			PTHREAD_MUTEX_UNLOCK(&mutex);
+				_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		}
 	}
 	

mpi/tests/mpi_isend_detached.c

@@ -32,10 +32,10 @@ void callback(void *arg __attribute__((unused)))
 {
 	unsigned *sent = arg;
 	
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	*sent = 1;
-	PTHREAD_COND_SIGNAL(&cond);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -75,10 +75,10 @@ int main(int argc, char **argv)
 			int sent = 0;
 			starpu_mpi_isend_detached(tab_handle, other_rank, loop, MPI_COMM_WORLD, callback, &sent);
 
-			PTHREAD_MUTEX_LOCK(&mutex);
+			_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 			while (!sent)
-				PTHREAD_COND_WAIT(&cond, &mutex);
-			PTHREAD_MUTEX_UNLOCK(&mutex);
+				_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+			_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 		}
 		else {
 			MPI_Status status;

tests/common/helper.h

@@ -39,23 +39,23 @@
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
 
 
-#define PTHREAD_MUTEX_INIT(mutex, attr) { int p_ret = pthread_mutex_init((mutex), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_init: %s\n", strerror(p_ret)); STARPU_ABORT(); }}
-#define PTHREAD_MUTEX_DESTROY(mutex) { int p_ret = pthread_mutex_destroy(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_destroy: %s\n", strerror(p_ret)); STARPU_ABORT(); }}
-#define PTHREAD_MUTEX_LOCK(mutex) { int p_ret = pthread_mutex_lock(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_lock : %s\n", strerror(p_ret)); STARPU_ABORT(); }}
-#define PTHREAD_MUTEX_UNLOCK(mutex) { int p_ret = pthread_mutex_unlock(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_unlock : %s\n", strerror(p_ret)); STARPU_ABORT(); }}
-
-#define PTHREAD_RWLOCK_INIT(rwlock, attr) { int p_ret = pthread_rwlock_init((rwlock), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_RWLOCK_RDLOCK(rwlock) { int p_ret = pthread_rwlock_rdlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_rdlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_RWLOCK_WRLOCK(rwlock) { int p_ret = pthread_rwlock_wrlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_wrlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_RWLOCK_UNLOCK(rwlock) { int p_ret = pthread_rwlock_unlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_unlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_RWLOCK_DESTROY(rwlock) { int p_ret = pthread_rwlock_destroy(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-
-#define PTHREAD_COND_INIT(cond, attr) { int p_ret = pthread_cond_init((cond), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_COND_DESTROY(cond) { int p_ret = pthread_cond_destroy(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_COND_SIGNAL(cond) { int p_ret = pthread_cond_signal(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_signal : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_COND_BROADCAST(cond) { int p_ret = pthread_cond_broadcast(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_broadcast : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_COND_WAIT(cond, mutex) { int p_ret = pthread_cond_wait((cond), (mutex)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_wait : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-
-#define PTHREAD_BARRIER_INIT(barrier, attr, count) { int p_ret = pthread_barrier_init((barrier), (attr), (count)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_barrier_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_BARRIER_DESTROY(barrier) { int p_ret = pthread_barrier_destroy((barrier)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_barrier_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
-#define PTHREAD_BARRIER_WAIT(barrier) { int p_ret = pthread_barrier_wait(barrier); if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == PTHREAD_BARRIER_SERIAL_THREAD)))) { fprintf(stderr, "pthread_barrier_wait : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_MUTEX_INIT(mutex, attr) { int p_ret = pthread_mutex_init((mutex), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_init: %s\n", strerror(p_ret)); STARPU_ABORT(); }}
+#define _STARPU_PTHREAD_MUTEX_DESTROY(mutex) { int p_ret = pthread_mutex_destroy(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_destroy: %s\n", strerror(p_ret)); STARPU_ABORT(); }}
+#define _STARPU_PTHREAD_MUTEX_LOCK(mutex) { int p_ret = pthread_mutex_lock(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_lock : %s\n", strerror(p_ret)); STARPU_ABORT(); }}
+#define _STARPU_PTHREAD_MUTEX_UNLOCK(mutex) { int p_ret = pthread_mutex_unlock(mutex); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_mutex_unlock : %s\n", strerror(p_ret)); STARPU_ABORT(); }}
+
+#define _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) { int p_ret = pthread_rwlock_init((rwlock), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) { int p_ret = pthread_rwlock_rdlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_rdlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) { int p_ret = pthread_rwlock_wrlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_wrlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) { int p_ret = pthread_rwlock_unlock(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_unlock : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) { int p_ret = pthread_rwlock_destroy(rwlock); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_rwlock_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+
+#define _STARPU_PTHREAD_COND_INIT(cond, attr) { int p_ret = pthread_cond_init((cond), (attr)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_COND_DESTROY(cond) { int p_ret = pthread_cond_destroy(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_COND_SIGNAL(cond) { int p_ret = pthread_cond_signal(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_signal : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_COND_BROADCAST(cond) { int p_ret = pthread_cond_broadcast(cond); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_broadcast : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_COND_WAIT(cond, mutex) { int p_ret = pthread_cond_wait((cond), (mutex)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_cond_wait : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+
+#define _STARPU_PTHREAD_BARRIER_INIT(barrier, attr, count) { int p_ret = pthread_barrier_init((barrier), (attr), (count)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_barrier_init : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_BARRIER_DESTROY(barrier) { int p_ret = pthread_barrier_destroy((barrier)); if (STARPU_UNLIKELY(p_ret)) { fprintf(stderr, "pthread_barrier_destroy : %s\n", strerror(p_ret)); STARPU_ABORT();}}
+#define _STARPU_PTHREAD_BARRIER_WAIT(barrier) { int p_ret = pthread_barrier_wait(barrier); if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == PTHREAD_BARRIER_SERIAL_THREAD)))) { fprintf(stderr, "pthread_barrier_wait : %s\n", strerror(p_ret)); STARPU_ABORT();}}

tests/core/execute_on_a_specific_worker.c

@@ -43,10 +43,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -123,10 +123,10 @@ int main(int argc, char **argv)
 		}
 	}
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (!finished)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(v_handle);
 	starpu_free(v);

tests/core/regenerate.c

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

tests/core/subgraph_repeat.c

@@ -67,9 +67,9 @@ static void callback_task_D(void *arg __attribute__((unused)))
 	if (loop_cnt == niter)
 	{
 		/* We are done */
-		PTHREAD_MUTEX_LOCK(&mutex);
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else {
 		int ret;
@@ -123,10 +123,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 */
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/core/subgraph_repeat_regenerate.c

@@ -68,9 +68,9 @@ static void callback_task_D(void *arg __attribute__((unused)))
 	{
 		/* We are done */
 		taskD.regenerate = 0;
-		PTHREAD_MUTEX_LOCK(&mutex);
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else {
 		int ret;
@@ -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 */
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	STARPU_ASSERT(check_cnt == (4*loop_cnt));
 

tests/datawizard/dsm_stress.c

@@ -44,10 +44,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -125,10 +125,10 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	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

@@ -88,22 +88,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);
-	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)
-		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;
-	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);
 
-	PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
 	starpu_data_release(thread_data->handle);
 }
 
@@ -115,16 +115,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 */
-	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;
-	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)
-		PTHREAD_COND_WAIT(&neighbour_data->recv_cond, &neighbour_data->recv_mutex);
+		_STARPU_PTHREAD_COND_WAIT(&neighbour_data->recv_cond, &neighbour_data->recv_mutex);
 	
-	PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
 
 	starpu_data_release(thread_data->handle);
 }
@@ -168,8 +168,8 @@ int main(int argc, char **argv)
 	{
 		problem_data[t].index = t;
 		problem_data[t].val = 0;
-		PTHREAD_COND_INIT(&problem_data[t].recv_cond, NULL);
-		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

@@ -99,7 +99,7 @@ static int test_recv_handle_async(void *arg)
 	int ret;
 	struct thread_data *thread_data = (struct thread_data *) arg;
 	
-	PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&thread_data->recv_mutex);
 
 	ret = (thread_data->recv_flag == 1);
 
@@ -109,7 +109,7 @@ static int test_recv_handle_async(void *arg)
 		thread_data->val = thread_data->recv_buf; 
 	}
 
-	PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&thread_data->recv_mutex);
 
 	if (ret)
 	{
@@ -132,11 +132,11 @@ static void recv_handle_async(void *_thread_data)
 	req->test_arg = thread_data;
 	req->next = NULL;
 
-	PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	req->next = data_req_list;
 	data_req_list = req;
-	PTHREAD_COND_SIGNAL(&data_req_cond);
-	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)
@@ -145,9 +145,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;
 	
-	PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	ret = (neighbour_data->recv_flag == 0);
-	PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&neighbour_data->recv_mutex);
 
 	if (ret)
 	{
@@ -168,35 +168,35 @@ static void send_handle_async(void *_thread_data)
 //	FPRINTF(stderr, "send_handle_async\n");
 
 	/* send the message */
-	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;
-	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;
 
-	PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	req->next = data_req_list;
 	data_req_list = req;
-	PTHREAD_COND_SIGNAL(&data_req_cond);
-	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)
 {
-	PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 	progress_thread_running = 1;
-	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)
-			PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
+			_STARPU_PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
 
 		req = data_req_list;
 
@@ -205,18 +205,18 @@ static void *progress_func(void *arg)
 			data_req_list = req->next;
 			req->next = NULL;
 
-			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);
-				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 */
-				PTHREAD_MUTEX_LOCK(&data_req_mutex);
+				_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 				struct data_req *req_aux = data_req_list;
 				if (!req_aux)
@@ -239,7 +239,7 @@ static void *progress_func(void *arg)
 			}
 		}
 	}
-	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	return NULL;
 }
@@ -291,8 +291,8 @@ int main(int argc, char **argv)
 
 	/* Create a thread to perform blocking calls */
 	pthread_t progress_thread;
-	PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
-	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;
 
@@ -301,17 +301,17 @@ int main(int argc, char **argv)
 	{
 		problem_data[t].index = t;
 		problem_data[t].val = 0;
-		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];
 	}
 
 	pthread_create(&progress_thread, NULL, progress_func, NULL);
 
-	PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	while (!progress_thread_running)
-		PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
-	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++)
 	{
@@ -326,10 +326,10 @@ int main(int argc, char **argv)
 		STARPU_ASSERT(retval == NULL);
 	}
 
-	PTHREAD_MUTEX_LOCK(&data_req_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	progress_thread_running = 0;
-	PTHREAD_COND_SIGNAL(&data_req_cond);
-	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
+	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	ret = pthread_join(progress_thread, &retval);
 	STARPU_ASSERT(!ret);

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -68,14 +68,14 @@ static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))
 {
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == NBUFFERS)
-		PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
 
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -110,9 +110,9 @@ int main(int argc, char **argv)
 		ret = starpu_task_wait_for_all();
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < NBUFFERS; b++)
@@ -123,12 +123,12 @@ int main(int argc, char **argv)
 		}
 
 		/* Wait for all buffers to be available */
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != NBUFFERS)
-			PTHREAD_COND_WAIT(&cond, &mutex);
+			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
-		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

@@ -68,14 +68,14 @@ static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))
 {
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == NBUFFERS)
-		PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
 
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 int main(int argc, char **argv)
@@ -106,9 +106,9 @@ int main(int argc, char **argv)
 			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 		}
 
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Grab the different pieces of data into main memory */
 		for (b = 0; b < NBUFFERS; b++)
@@ -119,12 +119,12 @@ int main(int argc, char **argv)
 		}
 
 		/* Wait for all buffers to be available */
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != NBUFFERS)
-			PTHREAD_COND_WAIT(&cond, &mutex);
+			_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
 		for (b = 0; b < NBUFFERS; b++)

tests/experiments/latency/cuda_latency.c

@@ -70,11 +70,11 @@ void send_data(unsigned src, unsigned dst)
 #endif
 
 	/* Tell the other GPU that data is in RAM */
-	PTHREAD_MUTEX_LOCK(&mutex_gpu);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
 	data_is_available[src] = 0;
 	data_is_available[dst] = 1;
-	PTHREAD_COND_SIGNAL(&cond_gpu);
-	PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond_gpu);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
 	//fprintf(stderr, "SEND on %d\n", src);
 }
 
@@ -83,12 +83,12 @@ void recv_data(unsigned src, unsigned dst)
 	cudaError_t cures;
 
 	/* Wait for the data to be in RAM */
-	PTHREAD_MUTEX_LOCK(&mutex_gpu);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex_gpu);
 	while (!data_is_available[dst])
 	{
-		PTHREAD_COND_WAIT(&cond_gpu, &mutex_gpu);
+		_STARPU_PTHREAD_COND_WAIT(&cond_gpu, &mutex_gpu);
 	}
-	PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex_gpu);
 	//fprintf(stderr, "RECV on %d\n", dst);
 
 	/* Upload data */
@@ -119,9 +119,9 @@ void *launch_gpu_thread(void *arg)
 	cudaMalloc(&gpu_buffer[id], buffer_size);
 	cudaStreamCreate(&stream[id]);
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	thread_is_initialized[id] = 1;
-	PTHREAD_COND_SIGNAL(&cond);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond);
 
 	if (id == 0)
 	{
@@ -134,9 +134,9 @@ void *launch_gpu_thread(void *arg)
 	nready_gpu++;
 
 	while (!ready)
-		PTHREAD_COND_WAIT(&cond_go, &mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
 
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	unsigned iter;
 	for (iter = 0; iter < niter; iter++)
@@ -151,10 +151,10 @@ void *launch_gpu_thread(void *arg)
 		}
 	}
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	nready_gpu--;
-	PTHREAD_COND_SIGNAL(&cond_go);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_SIGNAL(&cond_go);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return NULL;
 }
@@ -162,9 +162,9 @@ void *launch_gpu_thread(void *arg)
 int main(int argc, char **argv)
 {
 
-	PTHREAD_MUTEX_INIT(&mutex, NULL);
-	PTHREAD_COND_INIT(&cond, NULL);
-	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++)
@@ -172,12 +172,12 @@ int main(int argc, char **argv)
 		thread_is_initialized[id] = 0;
 		pthread_create(&thread[0], NULL, launch_gpu_thread, &id);
 
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		while (!thread_is_initialized[id])
 		{
-			 PTHREAD_COND_WAIT(&cond, &mutex);
+			 _STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
 		}
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 
 	struct timeval start;
@@ -186,18 +186,18 @@ int main(int argc, char **argv)
 	/* Start the ping pong */
 	gettimeofday(&start, NULL);
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	ready = 1;
-	PTHREAD_COND_BROADCAST(&cond_go);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(&cond_go);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	/* Wait for the end of the ping pong */
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	while (nready_gpu > 0)
 	{
-		PTHREAD_COND_WAIT(&cond_go, &mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond_go, &mutex);
 	}
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	gettimeofday(&end, NULL);
 	

tests/overlap/overlap.c

@@ -42,10 +42,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		PTHREAD_MUTEX_LOCK(&mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		PTHREAD_COND_SIGNAL(&cond);
-		PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_SIGNAL(&cond);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -115,10 +115,10 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
-	PTHREAD_MUTEX_LOCK(&mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		PTHREAD_COND_WAIT(&cond, &mutex);
-	PTHREAD_MUTEX_UNLOCK(&mutex);
+		_STARPU_PTHREAD_COND_WAIT(&cond, &mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(handle);
 	starpu_free(buffer);