yet more error checking

mpi/starpu_mpi.c

@@ -63,10 +63,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);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	pthread_cond_broadcast(&req->req_cond);
-	pthread_mutex_unlock(&req->req_mutex);
+	PTHREAD_COND_BROADCAST(&req->req_cond);
+	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 }
 
 int starpu_mpi_isend(starpu_data_handle data_handle, starpu_mpi_req *public_req, int dest, int mpi_tag, MPI_Comm comm)
@@ -83,7 +83,7 @@ int starpu_mpi_isend(starpu_data_handle data_handle, starpu_mpi_req *public_req,
 	req->submitted = 0;
 	req->completed = 0;
 	pthread_mutex_init(&req->req_mutex, NULL);
-	pthread_cond_init(&req->req_cond, NULL);
+	PTHREAD_COND_INIT(&req->req_cond, NULL);
 
 	req->request_type = SEND_REQ;
 
@@ -116,8 +116,8 @@ int starpu_mpi_isend_detached(starpu_data_handle data_handle,
 	/* Initialize the request structure */
 	req->submitted = 0;
 	req->completed = 0;
-	pthread_mutex_init(&req->req_mutex, NULL);
-	pthread_cond_init(&req->req_cond, NULL);
+	PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
+	PTHREAD_COND_INIT(&req->req_cond, NULL);
 
 	req->request_type = SEND_REQ;
 
@@ -161,10 +161,10 @@ static void starpu_mpi_irecv_func(struct starpu_mpi_req_s *req)
 	MPI_Irecv(ptr, 1, req->datatype, req->srcdst, req->mpi_tag, req->comm, &req->request);
 
 	/* somebody is perhaps waiting for the MPI request to be posted */
-	pthread_mutex_lock(&req->req_mutex);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->submitted = 1;
-	pthread_cond_broadcast(&req->req_cond);
-	pthread_mutex_unlock(&req->req_mutex);
+	PTHREAD_COND_BROADCAST(&req->req_cond);
+	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 }
 
 int starpu_mpi_irecv(starpu_data_handle data_handle, starpu_mpi_req *public_req, int source, int mpi_tag, MPI_Comm comm)
@@ -181,8 +181,8 @@ int starpu_mpi_irecv(starpu_data_handle data_handle, starpu_mpi_req *public_req,
 
 	/* Initialize the request structure */
 	req->submitted = 0;
-	pthread_mutex_init(&req->req_mutex, NULL);
-	pthread_cond_init(&req->req_cond, NULL);
+	PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
+	PTHREAD_COND_INIT(&req->req_cond, NULL);
 
 	req->request_type = RECV_REQ;
 
@@ -214,8 +214,8 @@ int starpu_mpi_irecv_detached(starpu_data_handle data_handle, int source, int mp
 
 	/* Initialize the request structure */
 	req->submitted = 0;
-	pthread_mutex_init(&req->req_mutex, NULL);
-	pthread_cond_init(&req->req_cond, NULL);
+	PTHREAD_MUTEX_INIT(&req->req_mutex, NULL);
+	PTHREAD_COND_INIT(&req->req_cond, NULL);
 
 	req->request_type = RECV_REQ;
 
@@ -296,14 +296,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);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	while (!req->submitted)
-		pthread_cond_wait(&req->req_cond, &req->req_mutex);
-	pthread_mutex_unlock(&req->req_mutex);
+		PTHREAD_COND_WAIT(&req->req_cond, &req->req_mutex);
+	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);
+	PTHREAD_MUTEX_INIT(&waiting_req.req_mutex, NULL);
+	PTHREAD_COND_INIT(&waiting_req.req_cond, NULL);
 	waiting_req.status = status;
 	waiting_req.other_request = req;
 	waiting_req.func = starpu_mpi_wait_func;
@@ -311,10 +311,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);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	while (!req->completed)
-		pthread_cond_wait(&req->req_cond, &req->req_mutex);
-	pthread_mutex_unlock(&req->req_mutex);
+		PTHREAD_COND_WAIT(&req->req_cond, &req->req_mutex);
+	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	ret = req->ret;
 
@@ -343,10 +343,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);
+	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);
+	PTHREAD_MUTEX_UNLOCK(&testing_req->req_mutex);
 }
 
 int starpu_mpi_test(starpu_mpi_req *public_req, int *flag, MPI_Status *status)
@@ -359,9 +359,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);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	unsigned submitted = req->submitted;
-	pthread_mutex_unlock(&req->req_mutex);
+	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 
 	if (submitted)
 	{
@@ -369,8 +369,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);
+		PTHREAD_MUTEX_INIT(&testing_req.req_mutex, NULL);
+		PTHREAD_COND_INIT(&testing_req.req_cond, NULL);
 		testing_req.flag = flag;
 		testing_req.status = status;
 		testing_req.other_request = req;
@@ -380,10 +380,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);
+		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);
+			PTHREAD_COND_WAIT(&testing_req.req_cond, &testing_req.req_mutex);
+		PTHREAD_MUTEX_UNLOCK(&testing_req.req_mutex);
 	
 		ret = testing_req.ret;
 
@@ -430,20 +430,20 @@ 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);
+	PTHREAD_MUTEX_LOCK(&req->req_mutex);
 	req->completed = 1;
-	pthread_cond_broadcast(&req->req_cond);
-	pthread_mutex_unlock(&req->req_mutex);
+	PTHREAD_COND_BROADCAST(&req->req_cond);
+	PTHREAD_MUTEX_UNLOCK(&req->req_mutex);
 }
 
 static void submit_mpi_req(void *arg)
 {
 	struct starpu_mpi_req_s *req = arg;
 
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	starpu_mpi_req_list_push_front(new_requests, req);
-	pthread_cond_broadcast(&cond);
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_COND_BROADCAST(&cond);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
 /*
@@ -454,13 +454,13 @@ static unsigned progression_hook_func(void *arg __attribute__((unused)))
 {
 	unsigned may_block = 1;
 
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (!starpu_mpi_req_list_empty(detached_requests))
 	{
 		pthread_cond_signal(&cond);
 		may_block = 0;
 	}
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return may_block;
 }
@@ -475,7 +475,7 @@ static void test_detached_requests(void)
 	MPI_Status status;
 	struct starpu_mpi_req_s *req, *next_req;
 
-	pthread_mutex_lock(&detached_requests_mutex);
+	PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
 
 	for (req = starpu_mpi_req_list_begin(detached_requests);
 		req != starpu_mpi_req_list_end(detached_requests);
@@ -483,7 +483,7 @@ static void test_detached_requests(void)
 	{
 		next_req = starpu_mpi_req_list_next(req);
 
-		pthread_mutex_unlock(&detached_requests_mutex);
+		PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
 
 		int ret = MPI_Test(&req->request, &flag, &status);
 		STARPU_ASSERT(ret == MPI_SUCCESS);
@@ -507,7 +507,7 @@ static void test_detached_requests(void)
 			handle_request_termination(req);
 		}
 
-		pthread_mutex_lock(&detached_requests_mutex);
+		PTHREAD_MUTEX_LOCK(&detached_requests_mutex);
 
 		if (flag)
 			starpu_mpi_req_list_erase(detached_requests, req);
@@ -518,7 +518,7 @@ static void test_detached_requests(void)
 		//	free(req);
 	}
 	
-	pthread_mutex_unlock(&detached_requests_mutex);
+	PTHREAD_MUTEX_UNLOCK(&detached_requests_mutex);
 }
 
 static void handle_new_request(struct starpu_mpi_req_s *req)
@@ -530,29 +530,29 @@ static void handle_new_request(struct starpu_mpi_req_s *req)
 
 	if (req->detached)
 	{
-		pthread_mutex_lock(&mutex);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		starpu_mpi_req_list_push_front(detached_requests, req);
-		pthread_mutex_unlock(&mutex);
+		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_MUTEX_LOCK(&mutex);
 		pthread_cond_signal(&cond);
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
 static void *progress_thread_func(void *arg __attribute__((unused)))
 {
 	/* notify the main thread that the progression thread is ready */
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	running = 1;
 	pthread_cond_signal(&cond);
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	while (running) {
 		/* shall we block ? */
 		unsigned block = starpu_mpi_req_list_empty(new_requests);
@@ -568,16 +568,16 @@ static void *progress_thread_func(void *arg __attribute__((unused)))
 //			if (rank == 3)
 //			fprintf(stderr, "<<<< STARPU MPI >>>> Rank %d NO MORE REQUESTS TO HANDLE\n", rank);
 
-			pthread_cond_wait(&cond, &mutex);
+			PTHREAD_COND_WAIT(&cond, &mutex);
 		}
 
 		if (!running)
 			break;		
 
 		/* test whether there are some terminated "detached request" */
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 		test_detached_requests();
-		pthread_mutex_lock(&mutex);
+		PTHREAD_MUTEX_LOCK(&mutex);
 
 		/* get one request */
 		struct starpu_mpi_req_s *req;
@@ -589,13 +589,13 @@ static void *progress_thread_func(void *arg __attribute__((unused)))
 			 * (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);
+			PTHREAD_MUTEX_UNLOCK(&mutex);
 			handle_new_request(req);
-			pthread_mutex_lock(&mutex);
+			PTHREAD_MUTEX_LOCK(&mutex);
 		}
 	}
 
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	return NULL;
 }
@@ -645,19 +645,19 @@ static void _starpu_mpi_add_sync_point_in_fxt(void)
 
 int starpu_mpi_initialize(void)
 {
-	pthread_mutex_init(&mutex, NULL);
-	pthread_cond_init(&cond, NULL);
+	PTHREAD_MUTEX_INIT(&mutex, NULL);
+	PTHREAD_COND_INIT(&cond, NULL);
 	new_requests = starpu_mpi_req_list_new();
 
-	pthread_mutex_init(&detached_requests_mutex, NULL);
+	PTHREAD_MUTEX_INIT(&detached_requests_mutex, NULL);
 	detached_requests = starpu_mpi_req_list_new();
 
 	int ret = pthread_create(&progress_thread, NULL, progress_thread_func, NULL);
 
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	while (!running)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 #ifdef USE_STARPU_ACTIVITY
 	hookid = starpu_register_progression_hook(progression_hook_func, NULL);
@@ -674,10 +674,10 @@ int starpu_mpi_shutdown(void)
 	void *value;
 
 	/* kill the progression thread */
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	running = 0;
-	pthread_cond_broadcast(&cond);
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_COND_BROADCAST(&cond);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	pthread_join(progress_thread, &value);
 

src/core/dependencies/cg.c

@@ -56,6 +56,8 @@ void _starpu_cg_list_deinit(struct starpu_cg_list_s *list)
 
 void _starpu_add_successor_to_cg_list(struct starpu_cg_list_s *successors, starpu_cg_t *cg)
 {
+	STARPU_ASSERT(cg);
+
 	/* where should that cg should be put in the array ? */
 	unsigned index = STARPU_ATOMIC_ADD(&successors->nsuccs, 1) - 1;
 
@@ -97,7 +99,7 @@ void _starpu_notify_cg(starpu_cg_t *cg)
 	 			 * tags, wake the thread */
 				PTHREAD_MUTEX_LOCK(&cg->succ.succ_apps.cg_mutex);
 				cg->succ.succ_apps.completed = 1;
-				pthread_cond_signal(&cg->succ.succ_apps.cg_cond);
+				PTHREAD_COND_SIGNAL(&cg->succ.succ_apps.cg_cond);
 				PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
 				break;
 
@@ -149,12 +151,18 @@ void _starpu_notify_cg_list(struct starpu_cg_list_s *successors)
 	for (succ = 0; succ < nsuccs; succ++)
 	{
 		struct starpu_cg_s *cg = successors->succ[succ];
-		struct starpu_tag_s *cgtag = cg->succ.tag;
+		STARPU_ASSERT(cg);
+
+		struct starpu_tag_s *cgtag;
 
 		unsigned cg_type = cg->cg_type;
 
 		if (cg_type == STARPU_CG_TAG)
+		{
+			cgtag = cg->succ.tag;
+			STARPU_ASSERT(cgtag);
 			_starpu_spin_lock(&cgtag->lock);
+		}
 
 		_starpu_notify_cg(cg);
 		if (cg_type == STARPU_CG_APPS) {

src/core/dependencies/tags.c

@@ -36,8 +36,8 @@ static starpu_cg_t *create_cg_apps(unsigned ntags)
 	cg->cg_type = STARPU_CG_APPS;
 
 	cg->succ.succ_apps.completed = 0;
-	pthread_mutex_init(&cg->succ.succ_apps.cg_mutex, NULL);
-	pthread_cond_init(&cg->succ.succ_apps.cg_cond, NULL);
+	PTHREAD_MUTEX_INIT(&cg->succ.succ_apps.cg_mutex, NULL);
+	PTHREAD_COND_INIT(&cg->succ.succ_apps.cg_cond, NULL);
 
 	return cg;
 }
@@ -336,8 +336,8 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 
 	PTHREAD_MUTEX_UNLOCK(&cg->succ.succ_apps.cg_mutex);
 
-	pthread_mutex_destroy(&cg->succ.succ_apps.cg_mutex);
-	pthread_cond_destroy(&cg->succ.succ_apps.cg_cond);
+	PTHREAD_MUTEX_DESTROY(&cg->succ.succ_apps.cg_mutex);
+	PTHREAD_COND_DESTROY(&cg->succ.succ_apps.cg_cond);
 
 	free(cg);
 

src/core/mechanisms/deque_queues.c

@@ -41,8 +41,8 @@ void _starpu_deinit_deque_queues_mechanisms(void)
 {
 	struct starpu_sched_policy_s *sched = _starpu_get_sched_policy();
 
-	pthread_mutex_destroy(&sched->sched_activity_mutex);
-	pthread_cond_destroy(&sched->sched_activity_cond);
+	PTHREAD_MUTEX_DESTROY(&sched->sched_activity_mutex);
+	PTHREAD_COND_DESTROY(&sched->sched_activity_cond);
 }
 
 struct starpu_jobq_s *_starpu_create_deque(void)
@@ -50,8 +50,8 @@ struct starpu_jobq_s *_starpu_create_deque(void)
 	struct starpu_jobq_s *jobq;
 	jobq = malloc(sizeof(struct starpu_jobq_s));
 
-	pthread_mutex_init(&jobq->activity_mutex, NULL);
-	pthread_cond_init(&jobq->activity_cond, NULL);
+	PTHREAD_MUTEX_INIT(&jobq->activity_mutex, NULL);
+	PTHREAD_COND_INIT(&jobq->activity_cond, NULL);
 
 	struct starpu_deque_jobq_s *deque;
 	deque = malloc(sizeof(struct starpu_deque_jobq_s));
@@ -118,7 +118,7 @@ int _starpu_deque_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* if anyone is blocked on the entire machine, wake it up */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
 	total_number_of_jobs++;
-	pthread_cond_signal(sched_cond);
+	PTHREAD_COND_SIGNAL(sched_cond);
 	PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	/* wake people waiting locally */
@@ -129,7 +129,7 @@ int _starpu_deque_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
 
-	pthread_cond_signal(&q->activity_cond);
+	PTHREAD_COND_SIGNAL(&q->activity_cond);
 	PTHREAD_MUTEX_UNLOCK(&q->activity_mutex);
 
 	return 0;

src/core/mechanisms/fifo_queues.c

@@ -40,8 +40,8 @@ struct starpu_jobq_s *_starpu_create_fifo(void)
 	struct starpu_jobq_s *jobq;
 	jobq = malloc(sizeof(struct starpu_jobq_s));
 
-	pthread_mutex_init(&jobq->activity_mutex, NULL);
-	pthread_cond_init(&jobq->activity_cond, NULL);
+	PTHREAD_MUTEX_INIT(&jobq->activity_mutex, NULL);
+	PTHREAD_COND_INIT(&jobq->activity_cond, NULL);
 
 	struct starpu_fifo_jobq_s *fifo;
 	fifo = malloc(sizeof(struct starpu_fifo_jobq_s));

src/core/mechanisms/priority_queues.c

@@ -53,8 +53,8 @@ struct starpu_jobq_s *_starpu_create_priority_jobq(void)
 	central_queue = malloc(sizeof(struct starpu_priority_jobq_s));
 	q->queue = central_queue;
 
-	pthread_mutex_init(&q->activity_mutex, NULL);
-	pthread_cond_init(&q->activity_cond, NULL);
+	PTHREAD_MUTEX_INIT(&q->activity_mutex, NULL);
+	PTHREAD_COND_INIT(&q->activity_cond, NULL);
 
 	central_queue->total_njobs = 0;
 
@@ -90,7 +90,7 @@ int _starpu_priority_push_task(struct starpu_jobq_s *q, starpu_job_t j)
 
 	/* if anyone is blocked on the entire machine, wake it up */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
-	pthread_cond_signal(sched_cond);
+	PTHREAD_COND_SIGNAL(sched_cond);
 	PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	/* wake people waiting locally */
@@ -104,7 +104,7 @@ int _starpu_priority_push_task(struct starpu_jobq_s *q, starpu_job_t j)
 	queue->njobs[priolevel]++;
 	queue->total_njobs++;
 
-	pthread_cond_signal(&q->activity_cond);
+	PTHREAD_COND_SIGNAL(&q->activity_cond);
 	PTHREAD_MUTEX_UNLOCK(&q->activity_mutex);
 
 	return 0;
@@ -125,7 +125,7 @@ starpu_job_t _starpu_priority_pop_task(struct starpu_jobq_s *q)
 #ifdef STARPU_NON_BLOCKING_DRIVERS
 		_starpu_datawizard_progress(q->memory_node, 1);
 #else
-		pthread_cond_wait(&q->activity_cond, &q->activity_mutex);
+		PTHREAD_COND_WAIT(&q->activity_cond, &q->activity_mutex);
 #endif
 	}
 

src/core/mechanisms/stack_queues.c

@@ -45,8 +45,8 @@ struct starpu_jobq_s *_starpu_create_stack(void)
 	struct starpu_stack_jobq_s *stack;
 	stack = malloc(sizeof(struct starpu_stack_jobq_s));
 
-	pthread_mutex_init(&jobq->activity_mutex, NULL);
-	pthread_cond_init(&jobq->activity_cond, NULL);
+	PTHREAD_MUTEX_INIT(&jobq->activity_mutex, NULL);
+	PTHREAD_COND_INIT(&jobq->activity_cond, NULL);
 
 	/* note that not all mechanisms (eg. the semaphore) have to be used */
 	stack->jobq = starpu_job_list_new();
@@ -94,7 +94,7 @@ void _starpu_stack_push_prio_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* if anyone is blocked on the entire machine, wake it up */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
 	total_number_of_jobs++;
-	pthread_cond_signal(sched_cond);
+	PTHREAD_COND_SIGNAL(sched_cond);
 	PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	/* wake people waiting locally */
@@ -105,7 +105,7 @@ void _starpu_stack_push_prio_task(struct starpu_jobq_s *q, starpu_job_t task)
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
 
-	pthread_cond_signal(&q->activity_cond);
+	PTHREAD_COND_SIGNAL(&q->activity_cond);
 	PTHREAD_MUTEX_UNLOCK(&q->activity_mutex);
 #else
 	_starpu_stack_push_task(q, task);
@@ -120,7 +120,7 @@ void _starpu_stack_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* if anyone is blocked on the entire machine, wake it up */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
 	total_number_of_jobs++;
-	pthread_cond_signal(sched_cond);
+	PTHREAD_COND_SIGNAL(sched_cond);
 	PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	/* wake people waiting locally */
@@ -131,7 +131,7 @@ void _starpu_stack_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
 
-	pthread_cond_signal(&q->activity_cond);
+	PTHREAD_COND_SIGNAL(&q->activity_cond);
 	PTHREAD_MUTEX_UNLOCK(&q->activity_mutex);
 }
 

src/core/policies/sched_policy.c

@@ -85,8 +85,8 @@ static void load_sched_policy(struct starpu_sched_policy_s *sched_policy)
 	policy.deinit_sched = sched_policy->deinit_sched;
 	policy.starpu_get_local_queue = sched_policy->starpu_get_local_queue;
 
-	pthread_cond_init(&policy.sched_activity_cond, NULL);
-	pthread_mutex_init(&policy.sched_activity_mutex, NULL);
+	PTHREAD_COND_INIT(&policy.sched_activity_cond, NULL);
+	PTHREAD_MUTEX_INIT(&policy.sched_activity_mutex, NULL);
 	pthread_key_create(&policy.local_queue_key, NULL);
 }
 
@@ -197,8 +197,8 @@ void _starpu_deinit_sched_policy(struct starpu_machine_config_s *config)
 		policy.deinit_sched(config, &policy);
 
 	pthread_key_delete(policy.local_queue_key);
-	pthread_mutex_destroy(&policy.sched_activity_mutex);
-	pthread_cond_destroy(&policy.sched_activity_cond);
+	PTHREAD_MUTEX_DESTROY(&policy.sched_activity_mutex);
+	PTHREAD_COND_DESTROY(&policy.sched_activity_cond);
 }
 
 /* the generic interface that call the proper underlying implementation */

src/core/workers.c

@@ -114,8 +114,8 @@ static void _starpu_init_workers(struct starpu_machine_config_s *config)
 
 		workerarg->config = config;
 
-		pthread_mutex_init(&workerarg->mutex, NULL);
-		pthread_cond_init(&workerarg->ready_cond, NULL);
+		PTHREAD_MUTEX_INIT(&workerarg->mutex, NULL);
+		PTHREAD_COND_INIT(&workerarg->ready_cond, NULL);
 
 		workerarg->workerid = (int)worker;
 
@@ -127,7 +127,7 @@ static void _starpu_init_workers(struct starpu_machine_config_s *config)
 		workerarg->terminated_jobs = starpu_job_list_new();
 
 		workerarg->local_jobs = starpu_job_list_new();
-		pthread_mutex_init(&workerarg->local_jobs_mutex, NULL);
+		PTHREAD_MUTEX_INIT(&workerarg->local_jobs_mutex, NULL);
 	
 		workerarg->status = STATUS_INITIALIZING;
 
@@ -458,7 +458,7 @@ static void _starpu_kill_all_workers(struct starpu_machine_config_s *config)
 	config->running = 0;
 
 	_starpu_operate_on_all_queues(BROADCAST);
-	pthread_cond_broadcast(&sched->sched_activity_cond);
+	PTHREAD_COND_BROADCAST(&sched->sched_activity_cond);
 
 	PTHREAD_MUTEX_UNLOCK(&sched->sched_activity_mutex);
 	_starpu_operate_on_all_queues(UNLOCK);

src/datawizard/copy_driver.c

@@ -40,7 +40,7 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 
 		/* wake anybody waiting on that queue */
 		PTHREAD_MUTEX_LOCK(&q->activity_mutex);
-		pthread_cond_broadcast(&q->activity_cond);
+		PTHREAD_COND_BROADCAST(&q->activity_cond);
 		PTHREAD_MUTEX_UNLOCK(&q->activity_mutex);
 	}
 
@@ -55,7 +55,7 @@ void starpu_wake_all_blocked_workers(void)
 	pthread_mutex_t *sched_mutex = &sched->sched_activity_mutex;
 
 	PTHREAD_MUTEX_LOCK(sched_mutex);
-	pthread_cond_broadcast(sched_cond);
+	PTHREAD_COND_BROADCAST(sched_cond);
 	PTHREAD_MUTEX_UNLOCK(sched_mutex);
 
 	/* workers may be blocked on the various queues' conditions */

src/datawizard/data_request.c

@@ -35,12 +35,12 @@ void _starpu_init_data_request_lists(void)
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
 		data_requests[i] = starpu_data_request_list_new();
-		pthread_mutex_init(&data_requests_list_mutex[i], NULL);
-		pthread_cond_init(&data_requests_list_cond[i], NULL);
+		PTHREAD_MUTEX_INIT(&data_requests_list_mutex[i], NULL);
+		PTHREAD_COND_INIT(&data_requests_list_cond[i], NULL);
 
 		data_requests_pending[i] = starpu_data_request_list_new();
-		pthread_mutex_init(&data_requests_pending_list_mutex[i], NULL);
-		pthread_cond_init(&data_requests_pending_list_cond[i], NULL);
+		PTHREAD_MUTEX_INIT(&data_requests_pending_list_mutex[i], NULL);
+		PTHREAD_COND_INIT(&data_requests_pending_list_cond[i], NULL);
 	}
 }
 
@@ -49,12 +49,12 @@ void _starpu_deinit_data_request_lists(void)
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
-		pthread_cond_destroy(&data_requests_pending_list_cond[i]);
-		pthread_mutex_destroy(&data_requests_pending_list_mutex[i]);
+		PTHREAD_COND_DESTROY(&data_requests_pending_list_cond[i]);
+		PTHREAD_MUTEX_DESTROY(&data_requests_pending_list_mutex[i]);
 		starpu_data_request_list_delete(data_requests_pending[i]);
 
-		pthread_cond_destroy(&data_requests_list_cond[i]);
-		pthread_mutex_destroy(&data_requests_list_mutex[i]);
+		PTHREAD_COND_DESTROY(&data_requests_list_cond[i]);
+		PTHREAD_MUTEX_DESTROY(&data_requests_list_mutex[i]);
 		starpu_data_request_list_delete(data_requests[i]);
 	}
 }

src/datawizard/user_interactions.c

@@ -137,8 +137,8 @@ int starpu_sync_data_with_mem_non_blocking(starpu_data_handle handle,
 	statenode->non_blocking = 1;
 	statenode->callback = callback;
 	statenode->callback_arg = arg;
-	pthread_cond_init(&statenode->cond, NULL);
-	pthread_mutex_init(&statenode->lock, NULL);
+	PTHREAD_COND_INIT(&statenode->cond, NULL);
+	PTHREAD_MUTEX_INIT(&statenode->lock, NULL);
 	statenode->finished = 0;
 
 	/* we try to get the data, if we do not succeed immediately, we set a

src/drivers/cpu/driver_cpu.c

@@ -134,7 +134,7 @@ void *_starpu_cpu_worker(void *arg)
         /* tell the main thread that we are ready */
 	PTHREAD_MUTEX_LOCK(&cpu_arg->mutex);
 	cpu_arg->worker_is_initialized = 1;
-	pthread_cond_signal(&cpu_arg->ready_cond);
+	PTHREAD_COND_SIGNAL(&cpu_arg->ready_cond);
 	PTHREAD_MUTEX_UNLOCK(&cpu_arg->mutex);
 
         starpu_job_t j;

src/drivers/gordon/driver_gordon.c

@@ -438,8 +438,8 @@ void *_starpu_gordon_worker(void *arg)
 	 */
 
 	/* launch the progression thread */
-	pthread_mutex_init(&progress_mutex, NULL);
-	pthread_cond_init(&progress_cond, NULL);
+	PTHREAD_MUTEX_INIT(&progress_mutex, NULL);
+	PTHREAD_COND_INIT(&progress_cond, NULL);
 	
 	pthread_create(&progress_thread, NULL, gordon_worker_progress, gordon_set_arg);