tests: test return values for pthread functionalities

tests/common/helper.h

@@ -33,3 +33,25 @@
 
 //#define STARPU_TEST_OUTPUT
 #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();}}

tests/core/execute_on_a_specific_worker.c

@@ -43,10 +43,10 @@ static void callback(void *arg)
 
 	if (res == 0)
 	{
-		pthread_mutex_lock(&mutex);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		pthread_cond_signal(&cond);
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 }
 
@@ -123,10 +123,10 @@ int main(int argc, char **argv)
 		}
 	}
 
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	while (!finished)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_free(v);
 	starpu_shutdown();

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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		completed = 1;
-		pthread_cond_signal(&cond);
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (!completed)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else {
 		/* Let's go for another iteration */
@@ -121,10 +121,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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 	}
 	else {
 		/* Let's go for another iteration */
@@ -126,10 +126,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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (loop_cnt < niter)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		pthread_cond_signal(&cond);
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(v_handle);
 	starpu_data_unregister(v_handle2);

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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == NBUFFERS)
-		pthread_cond_signal(&cond);
+		PTHREAD_COND_SIGNAL(&cond);
 
-	pthread_mutex_unlock(&mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		pthread_mutex_unlock(&mutex);
+		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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != NBUFFERS)
-			pthread_cond_wait(&cond, &mutex);
+			PTHREAD_COND_WAIT(&cond, &mutex);
 
-		pthread_mutex_unlock(&mutex);
+		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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 
 	n_synced_buffers++;
 
 	if (n_synced_buffers == NBUFFERS)
-		pthread_cond_signal(&cond);
+		PTHREAD_COND_SIGNAL(&cond);
 
-	pthread_mutex_unlock(&mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		n_synced_buffers = 0;
-		pthread_mutex_unlock(&mutex);
+		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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 
 		while (n_synced_buffers != NBUFFERS)
-			pthread_cond_wait(&cond, &mutex);
+			PTHREAD_COND_WAIT(&cond, &mutex);
 
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_MUTEX_UNLOCK(&mutex);
 
 		/* Release them */
 		for (b = 0; b < NBUFFERS; b++)

tests/experiments/latency/cuda_latency.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  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
@@ -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);
+	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);
+	PTHREAD_COND_SIGNAL(&cond_gpu);
+	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);
+	PTHREAD_MUTEX_LOCK(&mutex_gpu);
 	while (!data_is_available[dst])
 	{
-		pthread_cond_wait(&cond_gpu, &mutex_gpu);
+		PTHREAD_COND_WAIT(&cond_gpu, &mutex_gpu);
 	}
-	pthread_mutex_unlock(&mutex_gpu);
+	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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	thread_is_initialized[id] = 1;
-	pthread_cond_signal(&cond);
+	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);
+		PTHREAD_COND_WAIT(&cond_go, &mutex);
 
-	pthread_mutex_unlock(&mutex);
+	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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	nready_gpu--;
-	pthread_cond_signal(&cond_go);
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_COND_SIGNAL(&cond_go);
+	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);
+	PTHREAD_MUTEX_INIT(&mutex, NULL);
+	PTHREAD_COND_INIT(&cond, NULL);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		while (!thread_is_initialized[id])
 		{
-			 pthread_cond_wait(&cond, &mutex);
+			 PTHREAD_COND_WAIT(&cond, &mutex);
 		}
-		pthread_mutex_unlock(&mutex);
+		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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	ready = 1;
-	pthread_cond_broadcast(&cond_go);
-	pthread_mutex_unlock(&mutex);
+	PTHREAD_COND_BROADCAST(&cond_go);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	/* Wait for the end of the ping pong */
-	pthread_mutex_lock(&mutex);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	while (nready_gpu > 0)
 	{
-		pthread_cond_wait(&cond_go, &mutex);
+		PTHREAD_COND_WAIT(&cond_go, &mutex);
 	}
-	pthread_mutex_unlock(&mutex);
+	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);
+		PTHREAD_MUTEX_LOCK(&mutex);
 		finished = 1;
-		pthread_cond_signal(&cond);
-		pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_SIGNAL(&cond);
+		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);
+	PTHREAD_MUTEX_LOCK(&mutex);
 	if (!finished)
-		pthread_cond_wait(&cond, &mutex);
-	pthread_mutex_unlock(&mutex);
+		PTHREAD_COND_WAIT(&cond, &mutex);
+	PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_free(buffer);
 	starpu_shutdown();