tests: test return values for pthread functionalities

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);
+	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);
+		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);
+	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);
+	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);
+	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);
+	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);
+		PTHREAD_COND_WAIT(&neighbour_data->recv_cond, &neighbour_data->recv_mutex);
 	
-	pthread_mutex_unlock(&neighbour_data->recv_mutex);
+	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);
+		PTHREAD_COND_INIT(&problem_data[t].recv_cond, NULL);
+		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);
+	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);
+	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);
+	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);
+	PTHREAD_COND_SIGNAL(&data_req_cond);
+	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);
+	PTHREAD_MUTEX_LOCK(&neighbour_data->recv_mutex);
 	ret = (neighbour_data->recv_flag == 0);
-	pthread_mutex_unlock(&neighbour_data->recv_mutex);
+	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);
+	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);
+	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);
+	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);
+	PTHREAD_COND_SIGNAL(&data_req_cond);
+	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 }
 
 static void *progress_func(void *arg)
 {
-	pthread_mutex_lock(&data_req_mutex);
+	PTHREAD_MUTEX_LOCK(&data_req_mutex);
 
 	progress_thread_running = 1;
-	pthread_cond_signal(&data_req_cond);	
+	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);
+			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);
+			PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 			int ret = req->test_func(req->test_arg);
 
 			if (ret)
 			{
 				free(req);
-				pthread_mutex_lock(&data_req_mutex);
+				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);
+				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);
+	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	return NULL;
 }
@@ -289,8 +289,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);
+	PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
+	PTHREAD_COND_INIT(&data_req_cond, NULL);
 	data_req_list = NULL;
 	progress_thread_running = 0;
 
@@ -299,17 +299,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);
+		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);
+	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);
+		PTHREAD_COND_WAIT(&data_req_cond, &data_req_mutex);
+	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	for (t = 0; t < NTHREADS; t++)
 	{
@@ -323,10 +323,10 @@ int main(int argc, char **argv)
 		STARPU_ASSERT(retval == NULL);
 	}
 
-	pthread_mutex_lock(&data_req_mutex);
+	PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	progress_thread_running = 0;
-	pthread_cond_signal(&data_req_cond);
-	pthread_mutex_unlock(&data_req_mutex);
+	PTHREAD_COND_SIGNAL(&data_req_cond);
+	PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
 	ret = pthread_join(progress_thread, &retval);
 	STARPU_ASSERT(retval == NULL);