Define new public API starpu_pthread which is similar to the pthread API.

It is provided with 2 implementations: a pthread one and a Simgrid one.

Applications using StarPU and wishing to use the Simgrid StarPU
features should use it.

ChangeLog

@@ -109,6 +109,11 @@ New features:
   * starpu_malloc calls starpu_malloc_flags with a value of flag set
     to STARPU_MALLOC_PINNED
   * Define new function starpu_free_flags similarly to starpu_malloc_flags
+  * Define new public API starpu_pthread which is similar to the
+    pthread API. It is provided with 2 implementations: a pthread one
+    and a Simgrid one. Applications using StarPU and wishing to use
+    the Simgrid StarPU features should use it.
+
 
 Small features:
   * Add starpu_worker_get_by_type and starpu_worker_get_by_devid

examples/audio/starpu_audio_processing.c

@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2010-2012  Université de Bordeaux 1
  * Copyright (C) 2010  Mehdi Juhoor <mjuhoor@gmail.com>
- * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
+ * 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
@@ -20,7 +20,6 @@
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
-#include <pthread.h>
 #include <sys/types.h>
 #include <sys/time.h>
 
@@ -216,7 +215,7 @@ static void band_filter_kernel_gpu(void *descr[], __attribute__((unused)) void *
 }
 #endif
 
-static pthread_mutex_t fftw_mutex = PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t fftw_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 static void band_filter_kernel_cpu(void *descr[], __attribute__((unused)) void *arg)
 {
@@ -231,7 +230,7 @@ static void band_filter_kernel_cpu(void *descr[], __attribute__((unused)) void *
 		plans[workerid].Acopy = malloc(nsamples*sizeof(float));
 
 		/* create plans, only "fftwf_execute" is thread safe in FFTW ... */
-		pthread_mutex_lock(&fftw_mutex);
+		starpu_pthread_mutex_lock(&fftw_mutex);
 		plans[workerid].plan_cpu = fftwf_plan_dft_r2c_1d(nsamples,
 					plans[workerid].Acopy,
 					plans[workerid].localout_cpu,
@@ -240,7 +239,7 @@ static void band_filter_kernel_cpu(void *descr[], __attribute__((unused)) void *
 					plans[workerid].localout_cpu,
 					plans[workerid].Acopy,
 					FFTW_ESTIMATE);
-		pthread_mutex_unlock(&fftw_mutex);
+		starpu_pthread_mutex_unlock(&fftw_mutex);
 
 		plans[workerid].is_initialized = 1;
 	}

examples/sched_ctx/sched_ctx.c

@@ -16,7 +16,6 @@
  */
 
 #include <starpu.h>
-#include <pthread.h>
 
 #ifdef STARPU_QUICK_CHECK
 #define NTASKS 64
@@ -25,13 +24,13 @@
 #endif
 
 int tasks_executed = 0;
-pthread_mutex_t mut;
+starpu_pthread_mutex_t mut;
 
 static void sched_ctx_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {
-	pthread_mutex_lock(&mut);
+	starpu_pthread_mutex_lock(&mut);
 	tasks_executed++;
-	pthread_mutex_unlock(&mut);
+	starpu_pthread_mutex_unlock(&mut);
 }
 
 static struct starpu_codelet sched_ctx_codelet =
@@ -54,7 +53,7 @@ int main(int argc, char **argv)
 		return 77;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
-	pthread_mutex_init(&mut, NULL);
+	starpu_pthread_mutex_init(&mut, NULL);
 	int nprocs1 = 1;
 	int nprocs2 = 1;
 	int procs1[20], procs2[20];

examples/sched_ctx_utils/sched_ctx_utils.c

@@ -47,11 +47,11 @@ struct retvals
 
 #define NSAMPLES 1
 int first = 1;
-pthread_mutex_t mut;
+starpu_pthread_mutex_t mut;
 struct retvals rv[2];
 struct params p1, p2;
 
-pthread_key_t key;
+starpu_pthread_key_t key;
 
 void init()
 {
@@ -75,12 +75,12 @@ void init()
 
 	p1.id = 0;
 	p2.id = 1;
-	pthread_key_create(&key, NULL);
+	starpu_pthread_key_create(&key, NULL);
 }
 
 void update_sched_ctx_timing_results(double flops, double avg_timing)
 {
-	unsigned *id = pthread_getspecific(key);
+	unsigned *id = starpu_pthread_getspecific(key);
 	rv[*id].flops += flops;
 	rv[*id].avg_timing += avg_timing;
 }
@@ -90,7 +90,7 @@ void* start_bench(void *val)
 	struct params *p = (struct params*)val;
 	int i;
 
-	pthread_setspecific(key, &p->id);
+	starpu_pthread_setspecific(key, &p->id);
 
 	if(p->ctx != 0)
 		starpu_sched_ctx_set_context(&p->ctx);
@@ -100,14 +100,14 @@ void* start_bench(void *val)
 
 	if(p->ctx != 0)
 	{
-		pthread_mutex_lock(&mut);
+		starpu_pthread_mutex_lock(&mut);
 		if(first)
 		{
 			starpu_sched_ctx_delete(p->ctx);
 		}
 
 		first = 0;
-		pthread_mutex_unlock(&mut);
+		starpu_pthread_mutex_unlock(&mut);
 	}
 
 	rv[p->id].flops /= NSAMPLES;
@@ -128,23 +128,23 @@ void start_2benchs(void (*bench)(unsigned, unsigned))
 	printf("size %d\n", size2);
 	p2.nblocks = nblocks2;
 
-	pthread_t tid[2];
-	pthread_mutex_init(&mut, NULL);
+	starpu_pthread_t tid[2];
+	starpu_pthread_mutex_init(&mut, NULL);
 
 	struct timeval start;
 	struct timeval end;
 
 	gettimeofday(&start, NULL);
 
-	pthread_create(&tid[0], NULL, (void*)start_bench, (void*)&p1);
-	pthread_create(&tid[1], NULL, (void*)start_bench, (void*)&p2);
+	starpu_pthread_create(&tid[0], NULL, (void*)start_bench, (void*)&p1);
+	starpu_pthread_create(&tid[1], NULL, (void*)start_bench, (void*)&p2);
 
-	pthread_join(tid[0], NULL);
-	pthread_join(tid[1], NULL);
+	starpu_pthread_join(tid[0], NULL);
+	starpu_pthread_join(tid[1], NULL);
 
 	gettimeofday(&end, NULL);
 
-	pthread_mutex_destroy(&mut);
+	starpu_pthread_mutex_destroy(&mut);
 
 	double timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
 	timing /= 1000000;
@@ -169,7 +169,7 @@ void start_1stbench(void (*bench)(unsigned, unsigned))
 
 	gettimeofday(&end, NULL);
 
-	pthread_mutex_destroy(&mut);
+	starpu_pthread_mutex_destroy(&mut);
 
 	double timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
 	timing /= 1000000;
@@ -193,7 +193,7 @@ void start_2ndbench(void (*bench)(unsigned, unsigned))
 
 	gettimeofday(&end, NULL);
 
-	pthread_mutex_destroy(&mut);
+	starpu_pthread_mutex_destroy(&mut);
 
 	double timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
 	timing /= 1000000;

examples/scheduler/dummy_sched.c

@@ -15,7 +15,6 @@
  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  */
 
-#include <pthread.h>
 #include <starpu.h>
 
 #define NTASKS	32000
@@ -24,7 +23,7 @@
 struct dummy_sched_data
 {
 	struct starpu_task_list sched_list;
-	pthread_mutex_t policy_mutex;
+     	starpu_pthread_mutex_t policy_mutex;
 };
 
 static void init_dummy_sched(unsigned sched_ctx_id)
@@ -39,7 +38,7 @@ static void init_dummy_sched(unsigned sched_ctx_id)
 
 	starpu_sched_ctx_set_policy_data(sched_ctx_id, (void*)data);
 
-	pthread_mutex_init(&data->policy_mutex, NULL);
+	starpu_pthread_mutex_init(&data->policy_mutex, NULL);
 	FPRINTF(stderr, "Initialising Dummy scheduler\n");
 }
 
@@ -51,7 +50,7 @@ static void deinit_dummy_sched(unsigned sched_ctx_id)
 
 	starpu_sched_ctx_delete_worker_collection(sched_ctx_id);
 
-	pthread_mutex_destroy(&data->policy_mutex);
+	starpu_pthread_mutex_destroy(&data->policy_mutex);
 
 	free(data);
 
@@ -69,12 +68,12 @@ static int push_task_dummy(struct starpu_task *task)
 
 	/* lock all workers when pushing tasks on a list where all
 	   of them would pop for tasks */
-        pthread_mutex_lock(&data->policy_mutex);
+        starpu_pthread_mutex_lock(&data->policy_mutex);
 
 	starpu_task_list_push_front(&data->sched_list, task);
 
 	starpu_push_task_end(task);
-	pthread_mutex_unlock(&data->policy_mutex);
+	starpu_pthread_mutex_unlock(&data->policy_mutex);
 
 
         /*if there are no tasks block */
@@ -89,12 +88,12 @@ static int push_task_dummy(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
         {
                 worker = workers->get_next(workers, &it);
-		pthread_mutex_t *sched_mutex;
-                pthread_cond_t *sched_cond;
+		starpu_pthread_mutex_t *sched_mutex;
+                starpu_pthread_cond_t *sched_cond;
                 starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
-		pthread_mutex_lock(sched_mutex);
-                pthread_cond_signal(sched_cond);
-                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;
@@ -109,9 +108,9 @@ static struct starpu_task *pop_task_dummy(unsigned sched_ctx_id)
 	 * the calling worker. So we just take the head of the list and give it
 	 * to the worker. */
 	struct dummy_sched_data *data = (struct dummy_sched_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
-	pthread_mutex_lock(&data->policy_mutex);
+	starpu_pthread_mutex_lock(&data->policy_mutex);
 	struct starpu_task *task = starpu_task_list_pop_back(&data->sched_list);
-	pthread_mutex_unlock(&data->policy_mutex);
+	starpu_pthread_mutex_unlock(&data->policy_mutex);
 	return task;
 }
 

include/starpu.h

@@ -39,6 +39,7 @@ typedef unsigned long long uint64_t;
 #include <starpu_opencl.h>
 #endif
 
+#include <starpu_thread.h>
 #include <starpu_util.h>
 #include <starpu_data.h>
 #include <starpu_data_interfaces.h>

include/starpu_thread.h

@@ -0,0 +1,178 @@
+/* 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_H__
+#define __STARPU_THREAD_H__
+
+#include <starpu.h>
+
+#ifdef STARPU_SIMGRID
+#include <xbt/synchro_core.h>
+#include <msg/msg.h>
+#else
+#include <pthread.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ * Encapsulation of the pthread_create function.
+ */
+
+#ifdef STARPU_SIMGRID
+
+typedef int starpu_pthread_t;
+typedef int starpu_pthread_attr_t;
+
+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);
+int starpu_pthread_attr_destroy(starpu_pthread_attr_t *attr);
+int starpu_pthread_attr_setdetachstate(starpu_pthread_attr_t *attr, int detachstate);
+
+#else /* STARPU_SIMGRID */
+
+typedef pthread_t starpu_pthread_t;
+typedef pthread_attr_t starpu_pthread_attr_t;
+
+#define starpu_pthread_create pthread_create
+#define starpu_pthread_join pthread_join
+#define starpu_pthread_attr_init pthread_attr_init
+#define starpu_pthread_attr_destroy pthread_attr_destroy
+#define starpu_pthread_attr_setdetachstate pthread_attr_setdetachstate
+
+#endif /* STARPU_SIMGRID */
+/*
+ * Encapsulation of the pthread_mutex_* functions.
+ */
+
+#ifdef STARPU_SIMGRID
+typedef xbt_mutex_t starpu_pthread_mutex_t;
+typedef int starpu_pthread_mutexattr_t;
+
+#define STARPU_PTHREAD_MUTEX_INITIALIZER NULL
+
+int starpu_pthread_mutex_init(starpu_pthread_mutex_t *mutex, const starpu_pthread_mutexattr_t *mutexattr);
+int starpu_pthread_mutex_destroy(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex);
+
+#else /* !STARPU_SIMGRID */
+
+typedef pthread_mutex_t starpu_pthread_mutex_t;
+typedef pthread_mutexattr_t starpu_pthread_mutexattr_t;
+
+#define starpu_pthread_mutex_init pthread_mutex_init
+#define starpu_pthread_mutex_destroy pthread_mutex_destroy
+#define starpu_pthread_mutex_lock pthread_mutex_lock
+#define starpu_pthread_mutex_unlock pthread_mutex_unlock
+#define starpu_pthread_mutex_trylock pthread_mutex_trylock
+
+#define STARPU_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+#endif /* STARPU_SIMGRID */
+
+/*
+ * Encapsulation of the pthread_key_* functions.
+ */
+#ifdef STARPU_SIMGRID
+
+typedef int starpu_pthread_key_t;
+int starpu_pthread_key_create(starpu_pthread_key_t *key, void (*destr_function) (void *));
+int starpu_pthread_key_delete(starpu_pthread_key_t key);
+int starpu_pthread_setspecific(starpu_pthread_key_t key, const void *pointer);
+void *starpu_pthread_getspecific(starpu_pthread_key_t key);
+
+#else /* STARPU_SIMGRID */
+
+typedef pthread_key_t starpu_pthread_key_t;
+
+#define starpu_pthread_key_create pthread_key_create
+#define starpu_pthread_key_delete pthread_key_delete
+#define starpu_pthread_setspecific pthread_setspecific
+#define starpu_pthread_getspecific pthread_getspecific
+
+#endif /* STARPU_SIMGRID */
+
+/*
+ * Encapsulation of the pthread_cond_* functions.
+ */
+
+#ifdef STARPU_SIMGRID
+typedef xbt_cond_t starpu_pthread_cond_t;
+typedef int starpu_pthread_condattr_t;
+#define STARPU_PTHREAD_COND_INITIALIZER NULL
+
+int starpu_pthread_cond_init(starpu_pthread_cond_t *cond, starpu_pthread_condattr_t *cond_attr);
+int starpu_pthread_cond_signal(starpu_pthread_cond_t *cond);
+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);
+int starpu_pthread_cond_timedwait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex, const struct timespec *abstime);
+int starpu_pthread_cond_destroy(starpu_pthread_cond_t *cond);
+
+#else /* STARPU_SIMGRID */
+typedef pthread_cond_t starpu_pthread_cond_t;
+typedef pthread_condattr_t starpu_pthread_condattr_t;
+#define STARPU_PTHREAD_COND_INITIALIZER PTHREAD_COND_INITIALIZER
+
+#define starpu_pthread_cond_init pthread_cond_init
+#define starpu_pthread_cond_signal pthread_cond_signal
+#define starpu_pthread_cond_broadcast pthread_cond_broadcast
+#define starpu_pthread_cond_wait pthread_cond_wait
+#define starpu_pthread_cond_timedwait pthread_cond_timedwait
+#define starpu_pthread_cond_destroy pthread_cond_destroy
+
+#endif /* STARPU_SIMGRID */
+
+
+/*
+ * Encapsulation of the pthread_rwlock_* functions.
+ */
+
+#ifdef STARPU_SIMGRID
+typedef xbt_mutex_t starpu_pthread_rwlock_t;
+typedef int starpu_pthread_rwlockattr_t;
+
+int starpu_pthread_rwlock_init(starpu_pthread_rwlock_t *rwlock, const starpu_pthread_rwlockattr_t *attr);
+int starpu_pthread_rwlock_destroy(starpu_pthread_rwlock_t *rwlock);
+int starpu_pthread_rwlock_rdlock(starpu_pthread_rwlock_t *rwlock);
+int starpu_pthread_rwlock_wrlock(starpu_pthread_rwlock_t *rwlock);
+int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock);
+
+#else /* STARPU_SIMGRID */
+
+typedef pthread_rwlock_t starpu_pthread_rwlock_t;
+typedef pthread_rwlockattr_t starpu_pthread_rwlockattr_t;
+
+#define starpu_pthread_rwlock_init pthread_rwlock_init
+#define starpu_pthread_rwlock_destroy pthread_rwlock_destroy
+#define starpu_pthread_rwlock_rdlock pthread_rwlock_rdlock
+#define starpu_pthread_rwlock_wrlock pthread_rwlock_wrlock
+#define starpu_pthread_rwlock_unlock pthread_rwlock_unlock
+
+#endif /* STARPU_SIMGRID */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __STARPU_THREAD_H__ */
+
+

mpi/src/starpu_mpi.c

@@ -23,6 +23,7 @@
 #include <starpu_mpi_stats.h>
 #include <starpu_mpi_insert_task.h>
 #include <common/config.h>
+#include <common/thread.h>
 
 static void _starpu_mpi_submit_new_mpi_request(void *arg);
 static void _starpu_mpi_handle_request_termination(struct _starpu_mpi_req *req);
@@ -40,18 +41,18 @@ static struct _starpu_mpi_req_list *new_requests;
 
 /* The list of detached requests that have already been submitted to MPI */
 static struct _starpu_mpi_req_list *detached_requests;
-static _starpu_pthread_mutex_t detached_requests_mutex;
+static starpu_pthread_mutex_t detached_requests_mutex;
 
 /* Condition to wake up progression thread */
-static _starpu_pthread_cond_t cond_progression;
+static starpu_pthread_cond_t cond_progression;
 /* Condition to wake up waiting for all current MPI requests to finish */
-static _starpu_pthread_cond_t cond_finished;
-static _starpu_pthread_mutex_t mutex;
-static pthread_t progress_thread;
+static starpu_pthread_cond_t cond_finished;
+static starpu_pthread_mutex_t mutex;
+static starpu_pthread_t progress_thread;
 static int running = 0;
 
 /* Count requests posted by the application and not yet submitted to MPI, i.e pushed into the new_requests list */
-static _starpu_pthread_mutex_t mutex_posted_requests;
+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); }
@@ -1068,7 +1069,7 @@ int starpu_mpi_shutdown(void)
 	_STARPU_PTHREAD_COND_BROADCAST(&cond_progression);
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
-	pthread_join(progress_thread, &value);
+	starpu_pthread_join(progress_thread, &value);
 
 #ifdef STARPU_MPI_ACTIVITY
 	starpu_progression_hook_deregister(hookid);

mpi/src/starpu_mpi_private.h

@@ -23,8 +23,6 @@
 #include "starpu_mpi.h"
 #include "starpu_mpi_fxt.h"
 #include <common/list.h>
-#include <common/thread.h>
-#include <pthread.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -102,8 +100,8 @@ LIST_TYPE(_starpu_mpi_req,
 	int *flag;
 
 	int ret;
-	_starpu_pthread_mutex_t req_mutex;
-	_starpu_pthread_cond_t req_cond;
+	starpu_pthread_mutex_t req_mutex;
+	starpu_pthread_cond_t req_cond;
 
 	enum _starpu_mpi_request_type request_type; /* 0 send, 1 recv */
 

mpi/tests/mpi_irecv_detached.c

@@ -29,8 +29,8 @@
 float *tab;
 starpu_data_handle_t tab_handle;
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 void callback(void *arg __attribute__((unused)))
 {

mpi/tests/mpi_isend_detached.c

@@ -17,7 +17,7 @@
 
 #include <starpu_mpi.h>
 #include <common/thread.h>
-#include <pthread.h>
+
 #include "helper.h"
 
 #ifdef STARPU_QUICK_CHECK
@@ -27,8 +27,8 @@
 #endif
 #define SIZE	16
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 void callback(void *arg)
 {

mpi/tests/mpi_probe.c

@@ -29,8 +29,8 @@
 float *tab;
 starpu_data_handle_t tab_handle;
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 void callback(void *arg __attribute__((unused)))
 {

src/Makefile.am

@@ -131,6 +131,7 @@ libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES = 						\
 	common/timing.c						\
 	common/fxt.c						\
 	common/utils.c						\
+	common/thread.c						\
 	core/jobs.c						\
 	core/task.c						\
 	core/task_bundle.c					\

src/common/barrier.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * 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
@@ -16,6 +16,7 @@
 
 #include <common/barrier.h>
 #include <common/utils.h>
+#include <common/thread.h>
 
 int _starpu_barrier_init(struct _starpu_barrier *barrier, int count)
 {

src/common/barrier.h

@@ -22,17 +22,16 @@
 #undef PTHREAD_BARRIER_SERIAL_THREAD
 #endif
 
-#include <pthread.h>
-#include <common/thread.h>
+#include <starpu_thread.h>
 
 struct _starpu_barrier
 {
 	int count;
 	int reached_start;
 	int reached_exit;
-	_starpu_pthread_mutex_t mutex;
-	_starpu_pthread_mutex_t mutex_exit;
-	_starpu_pthread_cond_t cond;
+	starpu_pthread_mutex_t mutex;
+	starpu_pthread_mutex_t mutex_exit;
+	starpu_pthread_cond_t cond;
 };
 
 int _starpu_barrier_init(struct _starpu_barrier *barrier, int count);

src/common/barrier_counter.c

@@ -15,6 +15,7 @@
  */
 
 #include <common/barrier_counter.h>
+#include <common/thread.h>
 
 int _starpu_barrier_counter_init(struct _starpu_barrier_counter *barrier_c, int count)
 {

src/common/starpu_spinlock.c

@@ -111,7 +111,7 @@ int _starpu_spin_checklocked(struct _starpu_spinlock *lock)
 	STARPU_ASSERT(lock->taken);
 	return !lock->taken;
 #elif defined(STARPU_SPINLOCK_CHECK)
-	int ret = _STARPU_PTHREAD_MUTEX_TRYLOCK(&lock->errcheck_lock);
+	int ret = starpu_pthread_mutex_trylock(&lock->errcheck_lock);
 	STARPU_ASSERT(ret != 0);
 	return ret == 0;
 #elif defined(HAVE_PTHREAD_SPIN_LOCK)
@@ -133,7 +133,7 @@ int _starpu_spin_trylock(struct _starpu_spinlock *lock)
 	lock->taken = 1;
 	return 0;
 #elif defined(STARPU_SPINLOCK_CHECK)
-	int ret = _STARPU_PTHREAD_MUTEX_TRYLOCK(&lock->errcheck_lock);
+	int ret = starpu_pthread_mutex_trylock(&lock->errcheck_lock);
 	STARPU_ASSERT(!ret || (ret == EBUSY));
 	return ret;
 #elif defined(HAVE_PTHREAD_SPIN_LOCK)

src/common/starpu_spinlock.h

@@ -21,15 +21,14 @@
 #include <stdint.h>
 #include <pthread.h>
 #include <common/config.h>
-#include <common/thread.h>
 
 struct _starpu_spinlock
 {
 #ifdef STARPU_SIMGRID
 	int taken;
 #elif defined(STARPU_SPINLOCK_CHECK)
-	pthread_mutexattr_t errcheck_attr;
-	_starpu_pthread_mutex_t errcheck_lock;
+	starpu_pthread_mutexattr_t errcheck_attr;
+	starpu_pthread_mutex_t errcheck_lock;
 #elif defined(HAVE_PTHREAD_SPIN_LOCK)
 	_starpu_pthread_spinlock_t lock;
 #else

src/common/thread.c

@@ -0,0 +1,205 @@
+/* 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.
+ */
+
+#include <starpu.h>
+#include <common/thread.h>
+#include <core/simgrid.h>
+
+#ifdef STARPU_SIMGRID
+#include <xbt/synchro_core.h>
+#endif
+
+#ifdef STARPU_SIMGRID
+
+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)
+{
+	struct _starpu_pthread_args *_args = malloc(sizeof(*_args));
+	xbt_dynar_t _hosts;
+	_args->f = start_routine;
+	_args->arg = arg;
+	_hosts = MSG_hosts_as_dynar();
+	MSG_process_create(name, _starpu_simgrid_thread_start, _args,
+			   xbt_dynar_get_as(_hosts, (where), msg_host_t));
+	xbt_dynar_free(&_hosts);
+	return 0;
+}
+
+int starpu_pthread_create(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);
+}
+
+int starpu_pthread_join(starpu_pthread_t thread, void **retval)
+{
+#ifdef STARPU_DEVEL
+#warning TODO: use a simgrid_join when it becomes available
+#endif
+	MSG_process_sleep(1);
+	return 0;
+}
+
+int starpu_pthread_attr_init(starpu_pthread_attr_t *attr)
+{
+	return 0;
+}
+
+int starpu_pthread_attr_destroy(starpu_pthread_attr_t *attr)
+{
+	return 0;
+}
+
+int starpu_pthread_attr_setdetachstate(starpu_pthread_attr_t *attr, int detachstate)
+{
+	return 0;
+}
+
+int starpu_pthread_mutex_init(starpu_pthread_mutex_t *mutex, const starpu_pthread_mutexattr_t *mutexattr)
+{
+	*mutex = xbt_mutex_init();
+	return 0;
+}
+
+int starpu_pthread_mutex_destroy(starpu_pthread_mutex_t *mutex)
+{
+	if (*mutex)
+		xbt_mutex_destroy(*mutex);
+	return 0;
+}
+
+int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex)
+{
+	if (!*mutex) _STARPU_PTHREAD_MUTEX_INIT(mutex, NULL);
+	xbt_mutex_acquire(*mutex);
+	return 0;
+}
+
+int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex)
+{
+	xbt_mutex_release(*mutex);
+	return 0;
+}
+
+int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex)
+{
+	xbt_mutex_acquire(*mutex);
+	return 0;
+}
+
+static int used_key[MAX_TSD];
+
+int starpu_pthread_key_create(starpu_pthread_key_t *key, void (*destr_function) (void *))
+{
+	unsigned i;
+
+	/* Note: no synchronization here, we are actually monothreaded anyway. */
+	for (i = 0; i < MAX_TSD; i++)
+		if (!used_key[i])
+		{
+			used_key[i] = 1;
+			break;
+		}
+	STARPU_ASSERT(i < MAX_TSD);
+	*key = i;
+	return 0;
+}
+
+int starpu_pthread_key_delete(starpu_pthread_key_t key)
+{
+	used_key[key] = 0;
+	return 0;
+}
+
+int starpu_pthread_setspecific(starpu_pthread_key_t key, const void *pointer)
+{
+	void **array = MSG_host_get_data(MSG_host_self());
+	array[key] = pointer;
+	return 0;
+}
+
+void* starpu_pthread_getspecific(starpu_pthread_key_t key)
+{
+	void **array = MSG_host_get_data(MSG_host_self());
+	return array[key];
+}
+
+int starpu_pthread_cond_init(starpu_pthread_cond_t *cond, starpu_pthread_condattr_t *cond_attr)
+{
+	*cond = xbt_cond_init();
+	return 0;
+}
+
+int starpu_pthread_cond_signal(starpu_pthread_cond_t *cond)
+{
+	if (!*cond)
+		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+	xbt_cond_signal(*cond);
+	return 0;
+}
+
+int starpu_pthread_cond_broadcast(starpu_pthread_cond_t *cond)
+{
+	if (!*cond)
+		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+	xbt_cond_broadcast(*cond);
+	return 0;
+}
+
+int starpu_pthread_cond_wait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex)
+{
+	if (!*cond)
+		_STARPU_PTHREAD_COND_INIT(cond, NULL);
+	xbt_cond_wait(*cond, *mutex);
+	return 0;
+}
+
+int starpu_pthread_cond_destroy(starpu_pthread_cond_t *cond)
+{
+	if (*cond)
+		xbt_cond_destroy(*cond);
+	return 0;
+}
+
+int starpu_pthread_rwlock_init(starpu_pthread_rwlock_t *restrict rwlock, const starpu_pthread_rwlockattr_t *restrict attr)
+{
+	return starpu_pthread_mutex_init(rwlock, attr);
+}
+
+int starpu_pthread_rwlock_destroy(starpu_pthread_rwlock_t *rwlock)
+{
+	return starpu_pthread_mutex_destroy(rwlock);
+}
+
+int starpu_pthread_rwlock_rdlock(starpu_pthread_rwlock_t *rwlock)
+{
+	return starpu_pthread_mutex_lock(rwlock);
+}
+
+int starpu_pthread_rwlock_wrlock(starpu_pthread_rwlock_t *rwlock)
+{
+	return starpu_pthread_mutex_lock(rwlock);
+}
+
+int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock)
+{
+	return starpu_pthread_mutex_unlock(rwlock);
+}
+
+
+
+#endif /* STARPU_SIMGRID */

src/common/thread.h

@@ -19,351 +19,222 @@
 #define __COMMON_THREAD_H__
 
 #include <starpu.h>
-#include <pthread.h>
-#ifdef STARPU_SIMGRID
-#include <xbt/synchro_core.h>
-#include <msg/msg.h>
-#endif
 
-#ifdef STARPU_SIMGRID
-typedef xbt_mutex_t _starpu_pthread_mutex_t;
-#else
-typedef pthread_mutex_t _starpu_pthread_mutex_t;
-#endif
+/*
+ * Encapsulation of the starpu_pthread_create_* functions.
+ */
 
-int _starpu_check_mutex_deadlock(_starpu_pthread_mutex_t *mutex);
-
-struct _starpu_pthread_args {
-	void *(*f)(void*);
-	void *arg;
-};
-
-int _starpu_simgrid_thread_start(int argc, char *argv[]);
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, threadarg, where) do {\
-	struct _starpu_pthread_args *_args = malloc(sizeof(*_args));           \
-	xbt_dynar_t _hosts;                                                    \
-	_args->f = routine;                                                    \
-	_args->arg = threadarg;                                                \
-	_hosts = MSG_hosts_as_dynar();                                         \
-	MSG_process_create((name), _starpu_simgrid_thread_start, _args,        \
-			xbt_dynar_get_as(_hosts, (where), msg_host_t));        \
-	xbt_dynar_free(&_hosts);                                               \
+#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)
-#else
-#define _STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, where) do {\
-	int p_ret = pthread_create((thread), (attr), (routine), (arg));	       \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
-		fprintf(stderr,                                                \
-			"%s:%d pthread_create: %s\n",                          \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-	}                                                                      \
-} while (0)
-#endif
-#define _STARPU_PTHREAD_CREATE(name, thread, attr, routine, arg)               \
+
+#define _STARPU_PTHREAD_CREATE(name, thread, attr, routine, arg)               		\
 	_STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, 0)
 
 /*
- * Encapsulation of the pthread_key_* functions.
+ * Encapsulation of the starpu_pthread_mutex_* functions.
  */
-#ifdef STARPU_SIMGRID
-typedef int _starpu_pthread_key_t;
-int _starpu_pthread_key_create(_starpu_pthread_key_t *key);
-#define _STARPU_PTHREAD_KEY_CREATE(key, destr) _starpu_pthread_key_create(key)
-int _starpu_pthread_key_delete(_starpu_pthread_key_t key);
-#define _STARPU_PTHREAD_KEY_DELETE(key) _starpu_pthread_key_delete(key)
-int _starpu_pthread_setspecific(_starpu_pthread_key_t key, void *ptr);
-#define _STARPU_PTHREAD_SETSPECIFIC(key, ptr) _starpu_pthread_setspecific(key, ptr)
-void *_starpu_pthread_getspecific(_starpu_pthread_key_t key);
-#define _STARPU_PTHREAD_GETSPECIFIC(key) _starpu_pthread_getspecific(key)
-#else
-typedef pthread_key_t _starpu_pthread_key_t;
-#define _STARPU_PTHREAD_KEY_CREATE(key, destr) do {                            \
-	int p_ret = pthread_key_create((key), (destr));	                       \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
-		fprintf(stderr,                                                \
-			"%s:%d pthread_key_create: %s\n",                      \
-			__FILE__, __LINE__, strerror(p_ret));                  \
-	}                                                                      \
-} while (0)
 
-#define _STARPU_PTHREAD_KEY_DELETE(key) do {                                   \
-	int p_ret = pthread_key_delete((key));	                               \
-	if (STARPU_UNLIKELY(p_ret != 0)) {                                     \
+#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 pthread_key_delete: %s\n",                      \
+			"%s:%d starpu_pthread_mutex_init: %s\n",               \
 			__FILE__, __LINE__, strerror(p_ret));                  \
+		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
 
-#define _STARPU_PTHREAD_SETSPECIFIC(key, ptr) do {                             \
-	int p_ret = pthread_setspecific((key), (ptr));	                       \
-	if (STARPU_UNLIKELY(p_ret != 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 pthread_setspecific: %s\n",                     \
+			"%s:%d starpu_pthread_mutex_destroy: %s\n",            \
 			__FILE__, __LINE__, strerror(p_ret));                  \
-	};                                                                     \
-} while (0)
-
-#define _STARPU_PTHREAD_GETSPECIFIC(key) pthread_getspecific((key))
-#endif
+		STARPU_ABORT();                                                \
+	}                                                                      \
+} while(0)
 
-/*
- * Encapsulation of the pthread_mutex_* functions.
- */
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_MUTEX_INITIALIZER NULL
-#define _STARPU_PTHREAD_MUTEX_INIT(mutex, attr) do {                           \
-	(*mutex) = xbt_mutex_init();                                           \
-} while (0)
-#else
-#define _STARPU_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
-#define _STARPU_PTHREAD_MUTEX_INIT(mutex, attr) do {                           \
-	int p_ret = pthread_mutex_init((mutex), (attr));                       \
+#define _STARPU_PTHREAD_MUTEX_LOCK(mutex) do {                                 \
+	int p_ret = starpu_pthread_mutex_lock(mutex);                          \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_mutex_init: %s\n",                      \
+			"%s:%d starpu_pthread_mutex_lock: %s\n",               \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_MUTEX_DESTROY(mutex) do {                              \
-	if (*mutex)                                                            \
-		xbt_mutex_destroy((*mutex));                                   \
-} while (0)
-#else
-#define _STARPU_PTHREAD_MUTEX_DESTROY(mutex) do {                              \
-	int p_ret = pthread_mutex_destroy(mutex);                              \
+#define _STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) do {                              \
+	int p_ret = starpu_pthread_mutex_trylock(mutex);                       \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_mutex_destroy: %s\n",                   \
+			"%s:%d starpu_pthread_mutex_trylock: %s\n",            \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
-} while(0)
-#endif
-
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_MUTEX_LOCK(mutex) do {                                 \
-	if (!(*mutex)) _STARPU_PTHREAD_MUTEX_INIT((mutex), NULL);              \
-	xbt_mutex_acquire((*mutex));                                           \
 } while (0)
-#else
-#define _STARPU_PTHREAD_MUTEX_LOCK(mutex) do {                                 \
-	int p_ret = pthread_mutex_lock(mutex);                                 \
+
+#define _STARPU_PTHREAD_MUTEX_UNLOCK(mutex) do {                               \
+	int p_ret = starpu_pthread_mutex_unlock(mutex);                        \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_mutex_lock: %s\n",                      \
+			"%s:%d starpu_pthread_mutex_unlock: %s\n",             \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) (xbt_mutex_acquire(*mutex), 0)
-#else
-#define _STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) pthread_mutex_trylock(mutex)
-#endif
+int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex);
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_MUTEX_UNLOCK(mutex) do {                               \
-	xbt_mutex_release((*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)
-#else
-#define _STARPU_PTHREAD_MUTEX_UNLOCK(mutex) do {                               \
-	int p_ret = pthread_mutex_unlock(mutex);                               \
-	if (STARPU_UNLIKELY(p_ret)) {                                          \
+
+#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 pthread_mutex_unlock: %s\n",                    \
+			"%s:%d starpu_pthread_key_delete: %s\n",               \
 			__FILE__, __LINE__, strerror(p_ret));                  \
-		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-typedef xbt_mutex_t _starpu_pthread_rwlock_t;
-#else
-typedef pthread_rwlock_t _starpu_pthread_rwlock_t;
-#endif
+#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 pthread_rwlock_* functions.
+ * Encapsulation of the starpu_pthread_rwlock_* functions.
  */
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) _STARPU_PTHREAD_MUTEX_INIT(rwlock, attr)
-#else
 #define _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) do {                         \
-	int p_ret = pthread_rwlock_init((rwlock), (attr));                     \
+	int p_ret = starpu_pthread_rwlock_init((rwlock), (attr));              \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_rwlock_init: %s\n",                     \
+			"%s:%d starpu_pthread_rwlock_init: %s\n",              \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) _STARPU_PTHREAD_MUTEX_LOCK(rwlock)
-#else
 #define _STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) do {                             \
-	int p_ret = pthread_rwlock_rdlock(rwlock);                             \
+	int p_ret = starpu_pthread_rwlock_rdlock(rwlock);                      \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_rwlock_rdlock: %s\n",                   \
+			"%s:%d starpu_pthread_rwlock_rdlock: %s\n",            \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) _STARPU_PTHREAD_MUTEX_LOCK(rwlock)
-#else
 #define _STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) do {                             \
-	int p_ret = pthread_rwlock_wrlock(rwlock);                             \
+	int p_ret = starpu_pthread_rwlock_wrlock(rwlock);                      \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_rwlock_wrlock: %s\n",                   \
+			"%s:%d starpu_pthread_rwlock_wrlock: %s\n",            \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) _STARPU_PTHREAD_MUTEX_UNLOCK(rwlock)
-#else
 #define _STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) do {                             \
-	int p_ret = pthread_rwlock_unlock(rwlock);                             \
+	int p_ret = starpu_pthread_rwlock_unlock(rwlock);                      \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_rwlock_unlock: %s\n",                   \
+			"%s:%d starpu_pthread_rwlock_unlock: %s\n",            \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) _STARPU_PTHREAD_MUTEX_DESTROY(rwlock)
-#else
 #define _STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) do {                            \
-	int p_ret = pthread_rwlock_destroy(rwlock);                            \
+	int p_ret = starpu_pthread_rwlock_destroy(rwlock);                     \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_rwlock_destroy: %s\n",                  \
+			"%s:%d starpu_pthread_rwlock_destroy: %s\n",           \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
-typedef xbt_cond_t _starpu_pthread_cond_t;
-#else
-typedef pthread_cond_t _starpu_pthread_cond_t;
-#endif
 /*
- * Encapsulation of the pthread_cond_* functions.
+ * Encapsulation of the starpu_pthread_cond_* functions.
  */
-#ifdef STARPU_SIMGRID
-#define _STARPU_PTHREAD_COND_INITIALIZER NULL
 #define _STARPU_PTHREAD_COND_INIT(cond, attr) do {                             \
-	(*cond) = xbt_cond_init();                                             \
-} while (0)
-#else
-#define _STARPU_PTHREAD_COND_INITIALIZER PTHREAD_COND_INITIALIZER
-#define _STARPU_PTHREAD_COND_INIT(cond, attr) do {                             \
-	int p_ret = pthread_cond_init((cond), (attr));                         \
+	int p_ret = starpu_pthread_cond_init((cond), (attr));                  \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_cond_init: %s\n",                       \
+			"%s:%d starpu_pthread_cond_init: %s\n",                \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
 #define _STARPU_PTHREAD_COND_DESTROY(cond) do {                                \
-	if (*cond)                                                             \
-		xbt_cond_destroy((*cond));                                     \
-} while (0)
-#else
-#define _STARPU_PTHREAD_COND_DESTROY(cond) do {                                \
-	int p_ret = pthread_cond_destroy(cond);                                \
+	int p_ret = starpu_pthread_cond_destroy(cond);                         \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_cond_destroy: %s\n",                    \
+			"%s:%d starpu_pthread_cond_destroy: %s\n",             \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 			STARPU_ABORT();                                        \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
 #define _STARPU_PTHREAD_COND_SIGNAL(cond) do {                                 \
-	if (!*cond)                                                            \
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);                         \
-	xbt_cond_signal((*cond));                                              \
-} while (0)
-#else
-#define _STARPU_PTHREAD_COND_SIGNAL(cond) do {                                 \
-	int p_ret = pthread_cond_signal(cond);                                 \
+	int p_ret = starpu_pthread_cond_signal(cond);                          \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_cond_signal: %s\n",                     \
+			"%s:%d starpu_pthread_cond_signal: %s\n",              \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
 #define _STARPU_PTHREAD_COND_BROADCAST(cond) do {                              \
-	if (!*cond)                                                            \
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);                         \
-	xbt_cond_broadcast((*cond));                                           \
-} while (0)
-#else
-#define _STARPU_PTHREAD_COND_BROADCAST(cond) do {                              \
-	int p_ret = pthread_cond_broadcast(cond);                              \
+	int p_ret = starpu_pthread_cond_broadcast(cond);                       \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_cond_broadcast: %s\n",                  \
+			"%s:%d starpu_pthread_cond_broadcast: %s\n",           \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#ifdef STARPU_SIMGRID
 #define _STARPU_PTHREAD_COND_WAIT(cond, mutex) do {                            \
-	if (!*cond)                                                            \
-		_STARPU_PTHREAD_COND_INIT(cond, NULL);                         \
-	xbt_cond_wait((*cond), (*mutex));                                      \
-} while (0)
-#else
-#define _STARPU_PTHREAD_COND_WAIT(cond, mutex) do {                            \
-	int p_ret = pthread_cond_wait((cond), (mutex));                        \
+	int p_ret = starpu_pthread_cond_wait((cond), (mutex));                 \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
 		fprintf(stderr,                                                \
-			"%s:%d pthread_cond_wait: %s\n",                       \
+			"%s:%d starpu_pthread_cond_wait: %s\n",                \
 			__FILE__, __LINE__, strerror(p_ret));                  \
 		STARPU_ABORT();                                                \
 	}                                                                      \
 } while (0)
-#endif
 
-#define _starpu_pthread_barrier_t pthread_barrier_t
 /*
- * Encapsulation of the pthread_barrier_* functions.
+ * 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)) {                                          \

src/common/utils.c

@@ -103,10 +103,10 @@ void _starpu_mkpath_and_check(const char *path, mode_t mode)
 	}
 }
 
-int _starpu_check_mutex_deadlock(_starpu_pthread_mutex_t *mutex)
+int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex)
 {
 	int ret;
-	ret = _STARPU_PTHREAD_MUTEX_TRYLOCK(mutex);
+	ret = starpu_pthread_mutex_trylock(mutex);
 	if (!ret)
 	{
 		_STARPU_PTHREAD_MUTEX_UNLOCK(mutex);

src/core/debug.c

@@ -21,7 +21,7 @@
 
 #ifdef STARPU_VERBOSE
 /* we want a single writer at the same time to have a log that is readable */
-static _starpu_pthread_mutex_t logfile_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t logfile_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 static FILE *logfile;
 #endif
 
@@ -76,7 +76,7 @@ struct ayudame_codelet
 	struct starpu_codelet *cl;
 } *codelets;
 static unsigned ncodelets, ncodelets_alloc;
-static _starpu_pthread_mutex_t ayudame_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t ayudame_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
 int64_t _starpu_ayudame_get_func_id(struct starpu_codelet *cl)
 {
 	unsigned i;

src/core/dependencies/cg.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010, 2012-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
@@ -90,8 +90,8 @@ struct _starpu_cg
 		struct
 		{
 			unsigned completed;
-			_starpu_pthread_mutex_t cg_mutex;
-			_starpu_pthread_cond_t cg_cond;
+			starpu_pthread_mutex_t cg_mutex;
+			starpu_pthread_cond_t cg_cond;
 		} succ_apps;
 	} succ;
 };

src/core/dependencies/tags.c

@@ -39,7 +39,7 @@ struct _starpu_tag_table
 #define HASH_FIND_UINT64_T(head,find,out) HASH_FIND(hh,head,find,sizeof(uint64_t),out)
 
 static struct _starpu_tag_table *tag_htbl = NULL;
-static _starpu_pthread_rwlock_t tag_global_rwlock;
+static starpu_pthread_rwlock_t tag_global_rwlock;
 
 static struct _starpu_cg *create_cg_apps(unsigned ntags)
 {

src/core/jobs.h

@@ -27,7 +27,6 @@
 #include <unistd.h>
 #include <string.h>
 #include <stdarg.h>
-#include <pthread.h>
 #include <common/config.h>
 #include <common/timing.h>
 #include <common/list.h>
@@ -38,6 +37,7 @@
 #include <core/errorcheck.h>
 #include <common/barrier.h>
 #include <common/utils.h>
+#include <common/thread.h>
 
 #ifdef STARPU_USE_CUDA
 #include <cuda.h>
@@ -63,8 +63,8 @@ LIST_TYPE(_starpu_job,
 
 	/* These synchronization structures are used to wait for the job to be
 	 * available or terminated for instance. */
-	_starpu_pthread_mutex_t sync_mutex;
-	_starpu_pthread_cond_t sync_cond;
+	starpu_pthread_mutex_t sync_mutex;
+	starpu_pthread_cond_t sync_cond;
 
 	/* To avoid deadlocks, we reorder the different buffers accessed to by
 	 * the task so that we always grab the rw-lock associated to the

src/core/perfmodel/perfmodel.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009-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) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -21,9 +21,7 @@
 
 #include <common/config.h>
 #include <starpu.h>
-#include <starpu_perfmodel.h>
 #include <core/task_bundle.h>
-#include <pthread.h>
 #include <stdio.h>
 
 struct _starpu_perfmodel_list

src/core/perfmodel/perfmodel_history.c

@@ -25,7 +25,6 @@
 #include <core/perfmodel/perfmodel.h>
 #include <core/jobs.h>
 #include <core/workers.h>
-#include <pthread.h>
 #include <datawizard/datawizard.h>
 #include <core/perfmodel/regression.h>
 #include <common/config.h>
@@ -50,7 +49,7 @@ struct starpu_perfmodel_history_table
 #define VALID_REGRESSION(reg_model) \
 	((reg_model)->minx < (9*(reg_model)->maxx)/10 && (reg_model)->nsample >= _STARPU_CALIBRATION_MINIMUM)
 
-static _starpu_pthread_rwlock_t registered_models_rwlock;
+static starpu_pthread_rwlock_t registered_models_rwlock;
 static struct _starpu_perfmodel_list *registered_models = NULL;
 
 size_t _starpu_job_get_data_size(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, unsigned nimpl, struct _starpu_job *j)

src/core/progress_hook.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
- * Copyright (C) 2010-2012  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010-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
@@ -15,7 +15,6 @@
  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  */
 
-#include <pthread.h>
 #include <core/workers.h>
 #include <common/utils.h>
 #include <core/progress_hook.h>
@@ -30,7 +29,7 @@ struct progression_hook
 };
 
 /* protect the hook table */
-static _starpu_pthread_rwlock_t progression_hook_rwlock;
+static starpu_pthread_rwlock_t progression_hook_rwlock;
 
 static struct progression_hook hooks[NMAXHOOKS] = {{NULL, NULL, 0}};
 static int active_hook_cnt = 0;

src/core/sched_ctx.c

@@ -18,13 +18,13 @@
 #include <core/sched_ctx.h>
 #include <common/utils.h>
 
-_starpu_pthread_mutex_t changing_ctx_mutex[STARPU_NMAX_SCHED_CTXS];
+starpu_pthread_mutex_t changing_ctx_mutex[STARPU_NMAX_SCHED_CTXS];
 
 extern struct starpu_worker_collection worker_list;
-static _starpu_pthread_mutex_t sched_ctx_manag = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_mutex_t finished_submit_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t sched_ctx_manag = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t finished_submit_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 struct starpu_task stop_submission_task = STARPU_TASK_INITIALIZER;
-pthread_key_t sched_ctx_key;
+starpu_pthread_key_t sched_ctx_key;
 unsigned with_hypervisor = 0;
 double max_time_worker_on_ctx = -1.0;
 
@@ -641,7 +641,7 @@ void starpu_sched_ctx_remove_workers(int *workers_to_remove, int nworkers_to_rem
 /* unused sched_ctx have the id STARPU_NMAX_SCHED_CTXS */
 void _starpu_init_all_sched_ctxs(struct _starpu_machine_config *config)
 {
-	pthread_key_create(&sched_ctx_key, NULL);
+	starpu_pthread_key_create(&sched_ctx_key, NULL);
 
 	unsigned i;
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -767,12 +767,12 @@ void _starpu_increment_nsubmitted_tasks_of_sched_ctx(unsigned sched_ctx_id)
 
 void starpu_sched_ctx_set_context(unsigned *sched_ctx)
 {
-	pthread_setspecific(sched_ctx_key, (void*)sched_ctx);
+	starpu_pthread_setspecific(sched_ctx_key, (void*)sched_ctx);
 }
 
 unsigned starpu_sched_ctx_get_context()
 {
-	unsigned *sched_ctx = (unsigned*)pthread_getspecific(sched_ctx_key);
+	unsigned *sched_ctx = (unsigned*)starpu_pthread_getspecific(sched_ctx_key);
 	if(sched_ctx == NULL)
 		return STARPU_NMAX_SCHED_CTXS;
 	STARPU_ASSERT(*sched_ctx < STARPU_NMAX_SCHED_CTXS);
@@ -883,7 +883,7 @@ int starpu_get_workers_of_sched_ctx(unsigned sched_ctx_id, int *pus, enum starpu
 	return npus;
 }
 
-_starpu_pthread_mutex_t* starpu_sched_ctx_get_changing_ctx_mutex(unsigned sched_ctx_id)
+starpu_pthread_mutex_t* starpu_sched_ctx_get_changing_ctx_mutex(unsigned sched_ctx_id)
 {
 	return &changing_ctx_mutex[sched_ctx_id];
 }

src/core/sched_ctx.h

@@ -30,7 +30,7 @@
 
 
 /* used when changes (delete, modify) are applyed to contexts */
-//extern _starpu_pthread_mutex_t _changing_ctx_mutex[];
+//extern starpu_pthread_mutex_t _changing_ctx_mutex[];
 
 struct _starpu_sched_ctx
 {
@@ -55,16 +55,16 @@ struct _starpu_sched_ctx
 	struct _starpu_barrier_counter tasks_barrier;
 
 	/* cond to block push when there are no workers in the ctx */
-	_starpu_pthread_cond_t no_workers_cond;
+	starpu_pthread_cond_t no_workers_cond;
 
 	/* mutex to block push when there are no workers in the ctx */
-	_starpu_pthread_mutex_t no_workers_mutex;
+	starpu_pthread_mutex_t no_workers_mutex;
 
 	/*ready tasks that couldn't be pushed because the ctx has no workers*/
 	struct starpu_task_list empty_ctx_tasks;
 
 	/* mutext protecting empty_ctx_tasks list */
-	_starpu_pthread_mutex_t empty_ctx_mutex;
+	starpu_pthread_mutex_t empty_ctx_mutex;
 
 	/* min CPUs to execute*/
 	int min_ncpus;
@@ -128,7 +128,7 @@ int _starpu_get_index_in_ctx_of_workerid(unsigned sched_ctx, unsigned workerid);
 unsigned _starpu_get_nsched_ctxs();
 
 /* Get the mutex corresponding to the global workerid */
-_starpu_pthread_mutex_t *_starpu_get_sched_mutex(struct _starpu_sched_ctx *sched_ctx, int worker);
+starpu_pthread_mutex_t *_starpu_get_sched_mutex(struct _starpu_sched_ctx *sched_ctx, int worker);
 
 /* Get workers belonging to a certain context, it returns the number of workers
  take care: no mutex taken, the list of workers might not be updated */
@@ -147,7 +147,7 @@ void _starpu_sched_ctx_call_poped_task_cb(int workerid, struct starpu_task *task
 #endif //STARPU_USE_SCHED_CTX_HYPERVISOR
 
 #if defined(_MSC_VER) || defined(STARPU_SIMGRID)
-_starpu_pthread_mutex_t* starpu_sched_ctx_get_changing_ctx_mutex(unsigned sched_ctx_id);
+starpu_pthread_mutex_t* starpu_sched_ctx_get_changing_ctx_mutex(unsigned sched_ctx_id);
 #endif
 
 #endif // __SCHED_CONTEXT_H__

src/core/simgrid.c

@@ -24,8 +24,6 @@
 #ifdef STARPU_SIMGRID
 #include <msg/msg.h>
 
-#define MAX_TSD 16
-
 #pragma weak starpu_main
 extern int starpu_main(int argc, char *argv[]);
 
@@ -132,8 +130,8 @@ LIST_TYPE(transfer,
 
 	/* communication termination signalization */
 	unsigned *finished;
-	_starpu_pthread_mutex_t *mutex;
-	_starpu_pthread_cond_t *cond;
+	starpu_pthread_mutex_t *mutex;
+	starpu_pthread_cond_t *cond;
 
 	/* transfers which wait for this transfer */
 	struct transfer **wake;
@@ -282,8 +280,8 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 	msg_host_t *hosts = calloc(2, sizeof(*hosts));
 	double *computation = calloc(2, sizeof(*computation));
 	double *communication = calloc(4, sizeof(*communication));
-	_starpu_pthread_mutex_t mutex;
-	_starpu_pthread_cond_t cond;
+	starpu_pthread_mutex_t mutex;
+	starpu_pthread_cond_t cond;
 	unsigned finished;
 
 	hosts[0] = _starpu_simgrid_memory_node_get_host(src_node);
@@ -345,43 +343,6 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 	}
 }
 
-static int used_key[MAX_TSD];
-
-int _starpu_pthread_key_create(_starpu_pthread_key_t *key)
-{
-	unsigned i;
-
-	/* Note: no synchronization here, we are actually monothreaded anyway. */
-	for (i = 0; i < MAX_TSD; i++)
-		if (!used_key[i])
-		{
-			used_key[i] = 1;
-			break;
-		}
-	STARPU_ASSERT(i < MAX_TSD);
-	*key = i;
-	return 0;
-}
-
-int _starpu_pthread_key_delete(_starpu_pthread_key_t key)
-{
-	used_key[key] = 0;
-	return 0;
-}
-
-int _starpu_pthread_setspecific(_starpu_pthread_key_t key, void *ptr)
-{
-	void **array = MSG_host_get_data(MSG_host_self());
-	array[key] = ptr;
-	return 0;
-}
-
-void* _starpu_pthread_getspecific(_starpu_pthread_key_t key)
-{
-	void **array = MSG_host_get_data(MSG_host_self());
-	return array[key];
-}
-
 int
 _starpu_simgrid_thread_start(int argc STARPU_ATTRIBUTE_UNUSED, char *argv[] STARPU_ATTRIBUTE_UNUSED)
 {

src/core/simgrid.h

@@ -17,9 +17,19 @@
 #ifndef __SIMGRID_H__
 #define __SIMGRID_H__
 
+#include <datawizard/data_request.h>
+
 #ifdef STARPU_SIMGRID
 #include <msg/msg.h>
 
+struct _starpu_pthread_args
+{
+	void *(*f)(void*);
+	void *arg;
+};
+
+#define MAX_TSD 16
+
 void _starpu_simgrid_execute_job(struct _starpu_job *job, enum starpu_perf_archtype perf_arch, double length);
 int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node, struct _starpu_data_request *req);
 /* Return the number of hosts prefixed by PREFIX */

src/core/task.c

@@ -35,8 +35,8 @@
 /* XXX this should be reinitialized when StarPU is shutdown (or we should make
  * sure that no task remains !) */
 /* TODO we could make this hierarchical to avoid contention ? */
-static _starpu_pthread_cond_t submitted_cond = _STARPU_PTHREAD_COND_INITIALIZER;
-static _starpu_pthread_mutex_t submitted_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t submitted_cond = STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t submitted_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 static long int nsubmitted = 0, nready = 0;
 
 static void _starpu_increment_nsubmitted_tasks(void);
@@ -45,7 +45,7 @@ static void _starpu_increment_nsubmitted_tasks(void);
  * cannot use the worker structure to store that information because it is
  * possible that we have a task with a NULL codelet, which means its callback
  * could be executed by a user thread as well. */
-static _starpu_pthread_key_t current_task_key;
+static starpu_pthread_key_t current_task_key;
 
 void starpu_task_init(struct starpu_task *task)
 {

src/core/task_bundle.c

@@ -23,6 +23,7 @@
 #include <common/config.h>
 #include <common/utils.h>
 #include <common/list.h>
+#include <common/thread.h>
 
 /* Initialize a task bundle */
 void starpu_task_bundle_create(starpu_task_bundle_t *bundle)

src/core/task_bundle.h

@@ -19,11 +19,7 @@
 #ifndef __CORE_TASK_BUNDLE_H__
 #define __CORE_TASK_BUNDLE_H__
 
-#if ! defined(_MSC_VER)
-#  include <pthread.h>
-#endif
-
-#include <common/thread.h>
+#include <starpu_thread.h>
 
 /* struct _starpu_task_bundle_entry
  * ================================
@@ -70,7 +66,7 @@ struct _starpu_task_bundle
 #if defined(_MSC_VER)
 	void *mutex;
 #else
-	_starpu_pthread_mutex_t mutex;
+	starpu_pthread_mutex_t mutex;
 #endif
 
 	struct _starpu_task_bundle_entry *list;

src/core/topology.c

@@ -684,7 +684,7 @@ _starpu_bind_thread_on_cpu (
 	CPU_ZERO(&aff_mask);
 	CPU_SET(cpuid, &aff_mask);
 
-	pthread_t self = pthread_self();
+	starpu_pthread_t self = pthread_self();
 
 	ret = pthread_setaffinity_np(self, sizeof(aff_mask), &aff_mask);
 	if (ret)

src/core/workers.c

@@ -42,12 +42,12 @@
 #endif
 
 /* acquire/release semantic for concurrent initialization/de-initialization */
-static _starpu_pthread_mutex_t init_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t init_cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t init_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t init_cond = STARPU_PTHREAD_COND_INITIALIZER;
 static int init_count = 0;
 static enum { UNINITIALIZED, CHANGING, INITIALIZED } initialized = UNINITIALIZED;
 
-static _starpu_pthread_key_t worker_key;
+static starpu_pthread_key_t worker_key;
 
 static struct _starpu_machine_config config;
 
@@ -257,8 +257,8 @@ int starpu_combined_worker_can_execute_task(unsigned workerid, struct starpu_tas
 
 static void _starpu_init_worker_queue(struct _starpu_worker *workerarg)
 {
-	_starpu_pthread_cond_t *cond = &workerarg->sched_cond;
-	_starpu_pthread_mutex_t *mutex = &workerarg->sched_mutex;
+	starpu_pthread_cond_t *cond = &workerarg->sched_cond;
+	starpu_pthread_mutex_t *mutex = &workerarg->sched_mutex;
 
 	unsigned memory_node = workerarg->memory_node;
 
@@ -843,23 +843,17 @@ static void _starpu_terminate_workers(struct _starpu_machine_config *pconfig)
 			if (!set->joined)
 			{
 #ifdef STARPU_SIMGRID
-#ifdef STARPU_DEVEL
-#warning TODO: use a simgrid_join when it becomes available
-#endif
-				MSG_process_sleep(1);
+				status = starpu_pthread_join(set->worker_thread, NULL);
 #else
 				if (!pthread_equal(pthread_self(), set->worker_thread))
-				{
-					status = pthread_join(set->worker_thread, NULL);
-#ifdef STARPU_VERBOSE
-					if (status)
-					{
-						_STARPU_DEBUG("pthread_join -> %d\n", status);
-                                        }
+					status = starpu_pthread_join(set->worker_thread, NULL);
 #endif
+#ifdef STARPU_VERBOSE
+				if (status)
+				{
+					_STARPU_DEBUG("starpu_pthread_join -> %d\n", status);
 				}
 #endif
-
 				set->joined = 1;
 			}
 		}
@@ -869,17 +863,15 @@ static void _starpu_terminate_workers(struct _starpu_machine_config *pconfig)
 				goto out;
 
 #ifdef STARPU_SIMGRID
-			MSG_process_sleep(1);
+			status = starpu_pthread_join(set->worker_thread, NULL);
 #else
 			if (!pthread_equal(pthread_self(), worker->worker_thread))
-			{
-				status = pthread_join(worker->worker_thread, NULL);
-#ifdef STARPU_VERBOSE
-				if (status)
-				{
-					_STARPU_DEBUG("pthread_join -> %d\n", status);
-                                }
+				status = starpu_pthread_join(worker->worker_thread, NULL);
 #endif
+#ifdef STARPU_VERBOSE
+			if (status)
+			{
+				_STARPU_DEBUG("starpu_pthread_join -> %d\n", status);
 			}
 #endif
 		}
@@ -1261,7 +1253,7 @@ void _starpu_worker_set_status(int workerid, enum _starpu_worker_status status)
 	config.workers[workerid].status = status;
 }
 
-void starpu_worker_get_sched_condition(int workerid, _starpu_pthread_mutex_t **sched_mutex, _starpu_pthread_cond_t **sched_cond)
+void starpu_worker_get_sched_condition(int workerid, starpu_pthread_mutex_t **sched_mutex, starpu_pthread_cond_t **sched_cond)
 {
 	*sched_cond = &config.workers[workerid].sched_cond;
 	*sched_mutex = &config.workers[workerid].sched_mutex;

src/core/workers.h

@@ -20,9 +20,7 @@
 #define __WORKERS_H__
 
 #include <starpu.h>
-#include <starpu_scheduler.h>
 #include <common/config.h>
-#include <pthread.h>
 #include <common/timing.h>
 #include <common/fxt.h>
 #include <core/jobs.h>
@@ -48,22 +46,22 @@
 struct _starpu_worker
 {
 	struct _starpu_machine_config *config;
-        _starpu_pthread_mutex_t mutex;
+        starpu_pthread_mutex_t mutex;
 	enum starpu_archtype arch; /* what is the type of worker ? */
 	uint32_t worker_mask; /* what is the type of worker ? */
 	enum starpu_perf_archtype perf_arch; /* in case there are different models of the same arch */
-	pthread_t worker_thread; /* the thread which runs the worker */
+	starpu_pthread_t worker_thread; /* the thread which runs the worker */
 	unsigned devid; /* which cpu/gpu/etc is controlled by the worker ? */
 	int bindid; /* which cpu is the driver bound to ? (logical index) */
 	int workerid; /* uniquely identify the worker among all processing units types */
 	int combined_workerid; /* combined worker currently using this worker */
 	int current_rank; /* current rank in case the worker is used in a parallel fashion */
 	int worker_size; /* size of the worker in case we use a combined worker */
-	_starpu_pthread_cond_t started_cond; /* indicate when the worker is ready */
-	_starpu_pthread_cond_t ready_cond; /* indicate when the worker is ready */
+	starpu_pthread_cond_t started_cond; /* indicate when the worker is ready */
+	starpu_pthread_cond_t ready_cond; /* indicate when the worker is ready */
 	unsigned memory_node; /* which memory node is the worker associated with ? */
-	_starpu_pthread_cond_t sched_cond; /* condition variable used when the worker waits for tasks. */
-	_starpu_pthread_mutex_t sched_mutex; /* mutex protecting sched_cond */
+	starpu_pthread_cond_t sched_cond; /* condition variable used when the worker waits for tasks. */
+        starpu_pthread_mutex_t sched_mutex; /* mutex protecting sched_cond */
 	struct starpu_task_list local_tasks; /* this queue contains tasks that have been explicitely submitted to that queue */
 	struct starpu_task *current_task; /* task currently executed by this worker */
 	struct _starpu_worker_set *set; /* in case this worker belongs to a set */
@@ -117,13 +115,13 @@ struct _starpu_combined_worker
  * accelerators (eg. Gordon for n SPUs) */
 struct _starpu_worker_set
 {
-        _starpu_pthread_mutex_t mutex;
-	pthread_t worker_thread; /* the thread which runs the worker */
+        starpu_pthread_mutex_t mutex;
+	starpu_pthread_t worker_thread; /* the thread which runs the worker */
 	unsigned nworkers;
 	unsigned joined; /* only one thread may call pthread_join*/
 	void *retval;
 	struct _starpu_worker *workers;
-        _starpu_pthread_cond_t ready_cond; /* indicate when the set is ready */
+        starpu_pthread_cond_t ready_cond; /* indicate when the set is ready */
 	unsigned set_is_initialized;
 };
 
@@ -199,7 +197,7 @@ unsigned _starpu_worker_can_block(unsigned memnode);
 /* This function must be called to block a worker. It puts the worker in a
  * sleeping state until there is some event that forces the worker to wake up.
  * */
-void _starpu_block_worker(int workerid, _starpu_pthread_cond_t *cond, _starpu_pthread_mutex_t *mutex);
+void _starpu_block_worker(int workerid, starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex);
 
 /* The _starpu_worker structure describes all the state of a StarPU worker.
  * This function sets the pthread key which stores a pointer to this structure.
@@ -246,7 +244,7 @@ int starpu_worker_get_nids_by_type(enum starpu_archtype type, int *workerids, in
 int starpu_worker_get_nids_ctx_free_by_type(enum starpu_archtype type, int *workerids, int maxsize);
 
 #if defined(_MSC_VER) || defined(STARPU_SIMGRID)
-void starpu_worker_get_sched_condition(int workerid, _starpu_pthread_mutex_t **sched_mutex, _starpu_pthread_cond_t **sched_cond);
+void starpu_worker_get_sched_condition(int workerid, starpu_pthread_mutex_t **sched_mutex, starpu_pthread_cond_t **sched_cond);
 #endif
 
 #endif // __WORKERS_H__

src/datawizard/coherency.h

@@ -117,8 +117,8 @@ struct _starpu_data_state
 	unsigned busy_count;
 	/* Is starpu_data_unregister waiting for busy_count? */
 	unsigned busy_waiting;
-	_starpu_pthread_mutex_t busy_mutex;
-	_starpu_pthread_cond_t busy_cond;
+	starpu_pthread_mutex_t busy_mutex;
+	starpu_pthread_cond_t busy_cond;
 
 	/* In case we user filters, the handle may describe a sub-data */
 	struct _starpu_data_state *root_handle; /* root of the tree */
@@ -156,7 +156,7 @@ struct _starpu_data_state
 
 	/* This lock should protect any operation to enforce
 	 * sequential_consistency */
-	_starpu_pthread_mutex_t sequential_consistency_mutex;
+	starpu_pthread_mutex_t sequential_consistency_mutex;
 
 	/* The last submitted task (or application data request) that declared
 	 * it would modify the piece of data ? Any task accessing the data in a

src/datawizard/copy_driver.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010, 2012  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
@@ -44,8 +44,8 @@ union _starpu_async_channel_event
 #ifdef STARPU_SIMGRID
 	struct {
 		unsigned finished;
-		_starpu_pthread_mutex_t mutex;
-		_starpu_pthread_cond_t cond;
+		starpu_pthread_mutex_t mutex;
+		starpu_pthread_cond_t cond;
 	};
 #endif
 #ifdef STARPU_USE_CUDA

src/datawizard/data_request.c

@@ -23,11 +23,11 @@
 /* requests that have not been treated at all */
 static struct _starpu_data_request_list *data_requests[STARPU_MAXNODES];
 static struct _starpu_data_request_list *prefetch_requests[STARPU_MAXNODES];
-static _starpu_pthread_mutex_t data_requests_list_mutex[STARPU_MAXNODES];
+static starpu_pthread_mutex_t data_requests_list_mutex[STARPU_MAXNODES];
 
 /* requests that are not terminated (eg. async transfers) */
 static struct _starpu_data_request_list *data_requests_pending[STARPU_MAXNODES];
-static _starpu_pthread_mutex_t data_requests_pending_list_mutex[STARPU_MAXNODES];
+static starpu_pthread_mutex_t data_requests_pending_list_mutex[STARPU_MAXNODES];
 
 void _starpu_init_data_request_lists(void)
 {

src/datawizard/interfaces/data_interface.c

@@ -386,8 +386,8 @@ struct _starpu_unregister_callback_arg
 	unsigned memory_node;
 	starpu_data_handle_t handle;
 	unsigned terminated;
-	_starpu_pthread_mutex_t mutex;
-	_starpu_pthread_cond_t cond;
+	starpu_pthread_mutex_t mutex;
+	starpu_pthread_cond_t cond;
 };
 
 /* Check whether we should tell starpu_data_unregister that the data handle is

src/datawizard/malloc.c

@@ -335,8 +335,8 @@ int starpu_free(void *A)
 }
 
 #ifdef STARPU_SIMGRID
-static _starpu_pthread_mutex_t cuda_alloc_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_mutex_t opencl_alloc_mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t cuda_alloc_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t opencl_alloc_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 #endif
 
 uintptr_t

src/datawizard/memalloc.c

@@ -22,7 +22,7 @@
 
 /* This per-node RW-locks protect mc_list and memchunk_cache entries */
 /* Note: handle header lock is always taken before this */
-static _starpu_pthread_rwlock_t mc_rwlock[STARPU_MAXNODES];
+static starpu_pthread_rwlock_t mc_rwlock[STARPU_MAXNODES];
 
 /* This per-node spinlock protect lru_list */
 static struct _starpu_spinlock lru_rwlock[STARPU_MAXNODES];

src/datawizard/memory_nodes.c

@@ -15,7 +15,6 @@
  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  */
 
-#include <pthread.h>
 #include <common/config.h>
 #include <core/sched_policy.h>
 #include <datawizard/datastats.h>
@@ -25,7 +24,7 @@
 #include "memalloc.h"
 
 static struct _starpu_memory_node_descr descr;
-static _starpu_pthread_key_t memory_node_key;
+static starpu_pthread_key_t memory_node_key;
 
 void _starpu_memory_nodes_init(void)
 {
@@ -139,7 +138,7 @@ msg_host_t _starpu_simgrid_memory_node_get_host(unsigned node)
 /* TODO move in a more appropriate file  !! */
 /* Register a condition variable associated to worker which is associated to a
  * memory node itself. */
-void _starpu_memory_node_register_condition(_starpu_pthread_cond_t *cond, _starpu_pthread_mutex_t *mutex, unsigned nodeid)
+void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex, unsigned nodeid)
 {
 	unsigned cond_id;
 	unsigned nconds_total, nconds;

src/datawizard/memory_nodes.h

@@ -34,8 +34,8 @@
 
 struct _starpu_cond_and_mutex
 {
-        _starpu_pthread_cond_t *cond;
-        _starpu_pthread_mutex_t *mutex;
+        starpu_pthread_cond_t *cond;
+        starpu_pthread_mutex_t *mutex;
 };
 
 struct _starpu_memory_node_descr
@@ -58,7 +58,7 @@ struct _starpu_memory_node_descr
 	 * multiple worker share the same condition variable, so we maintain a
 	 * list of all these condition variables so that we can wake up all
 	 * worker attached to a memory node that are waiting on a task. */
-	_starpu_pthread_rwlock_t conditions_rwlock;
+	starpu_pthread_rwlock_t conditions_rwlock;
 	struct _starpu_cond_and_mutex conditions_attached_to_node[STARPU_MAXNODES][STARPU_NMAXWORKERS];
 	struct _starpu_cond_and_mutex conditions_all[STARPU_MAXNODES*STARPU_NMAXWORKERS];
 	/* the number of queues attached to each node */
@@ -79,7 +79,7 @@ msg_host_t _starpu_simgrid_memory_node_get_host(unsigned node);
 #endif
 unsigned _starpu_memory_node_register(enum starpu_node_kind kind, int devid);
 //void _starpu_memory_node_attach_queue(struct starpu_jobq_s *q, unsigned nodeid);
-void _starpu_memory_node_register_condition(_starpu_pthread_cond_t *cond, _starpu_pthread_mutex_t *mutex, unsigned memory_node);
+void _starpu_memory_node_register_condition(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex, unsigned memory_node);
 
 int _starpu_memory_node_get_devid(unsigned node);
 

src/datawizard/user_interactions.c

@@ -51,8 +51,8 @@ struct user_interaction_wrapper
 	starpu_data_handle_t handle;
 	enum starpu_access_mode mode;
 	unsigned node;
-	_starpu_pthread_cond_t cond;
-	_starpu_pthread_mutex_t lock;
+	starpu_pthread_cond_t cond;
+	starpu_pthread_mutex_t lock;
 	unsigned finished;
 	unsigned async;
 	void (*callback)(void *);

src/drivers/gordon/driver_gordon.c

@@ -20,7 +20,6 @@
 #define _GNU_SOURCE
 #endif
 #include <sched.h>
-#include <pthread.h>
 #include <semaphore.h>
 #include <common/utils.h>
 #include "driver_gordon.h"
@@ -29,10 +28,10 @@
 
 static unsigned progress_thread_is_inited = 0;
 
-pthread_t progress_thread;
+starpu_pthread_t progress_thread;
 
-_starpu_pthread_cond_t progress_cond;
-_starpu_pthread_mutex_t progress_mutex;
+starpu_pthread_cond_t progress_cond;
+starpu_pthread_mutex_t progress_mutex;
 
 struct gordon_task_wrapper_s
 {

src/drivers/opencl/driver_opencl.c

@@ -37,7 +37,7 @@
 static int nb_devices = -1;
 static int init_done = 0;
 
-static _starpu_pthread_mutex_t big_lock = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t big_lock = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 static size_t global_mem[STARPU_MAXOPENCLDEVS];
 

src/profiling/bound.c

@@ -120,7 +120,7 @@ int _starpu_bound_recording;
 static int recorddeps;
 static int recordprio;
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 /* Initialization */
 void starpu_bound_start(int deps, int prio)

src/profiling/profiling.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2013  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
  *
  * 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
@@ -26,7 +26,7 @@
 #include <errno.h>
 
 static struct starpu_worker_profiling_info worker_info[STARPU_NMAXWORKERS];
-static _starpu_pthread_mutex_t worker_info_mutex[STARPU_NMAXWORKERS];
+static starpu_pthread_mutex_t worker_info_mutex[STARPU_NMAXWORKERS];
 
 /* In case the worker is still sleeping when the user request profiling info,
  * we need to account for the time elasped while sleeping. */

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -239,8 +239,8 @@ static struct starpu_task *dmda_pop_every_task(unsigned sched_ctx_id)
 	int workerid = starpu_worker_get_id();
 	struct _starpu_fifo_taskq *fifo = dt->queue_array[workerid];
 
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	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);
 	new_list = _starpu_fifo_pop_every_task(fifo, workerid);
@@ -271,8 +271,8 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 
 	struct _starpu_fifo_taskq *fifo = dt->queue_array[best_workerid];
 
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(best_workerid, &sched_mutex, &sched_cond);
 
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
@@ -398,8 +398,8 @@ static int _dm_push_task(struct starpu_task *task, unsigned prio, unsigned sched
 			}
 
 			double exp_end;
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			starpu_pthread_mutex_t *sched_mutex;
+			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 */
@@ -518,8 +518,8 @@ static void compute_all_performance_predictions(struct starpu_task *task,
 			}
 
 			/* Sometimes workers didn't take the tasks as early as we expected */
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			starpu_pthread_mutex_t *sched_mutex;
+			starpu_pthread_cond_t *sched_cond;
 			starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
 
 			STARPU_ASSERT_MSG(fifo != NULL, "worker %d ctx %d\n", worker, sched_ctx_id);
@@ -723,7 +723,7 @@ static int dmda_push_sorted_task(struct starpu_task *task)
 #warning TODO: after defining a scheduling window, use that instead of empty_ctx_tasks
 #endif
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 
@@ -744,7 +744,7 @@ static int dmda_push_sorted_task(struct starpu_task *task)
 static int dm_push_task(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 
@@ -764,7 +764,7 @@ static int dm_push_task(struct starpu_task *task)
 static int dmda_push_task(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 
@@ -893,8 +893,8 @@ static void dmda_pre_exec_hook(struct starpu_task *task)
 	double model = task->predicted;
 	double transfer_model = task->predicted_transfer;
 
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 
 	/* Once the task is executing, we can update the predicted amount
@@ -921,8 +921,8 @@ static void dmda_push_task_notify(struct starpu_task *task, int workerid, unsign
 			_starpu_get_job_associated_to_task(task)->nimpl);
 
 	double predicted_transfer = starpu_task_expected_data_transfer_time(memory_node, task);
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 
 

src/sched_policies/deque_queues.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2011  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
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -88,7 +88,7 @@ struct starpu_task *_starpu_deque_pop_task(struct _starpu_deque_jobq *deque_queu
 	return NULL;
 }
 
-struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq *deque_queue, _starpu_pthread_mutex_t *sched_mutex, int workerid)
+struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq *deque_queue, starpu_pthread_mutex_t *sched_mutex, int workerid)
 {
 	struct _starpu_job_list *new_list, *old_list;
 

src/sched_policies/deque_queues.h

@@ -44,7 +44,7 @@ struct _starpu_deque_jobq *_starpu_create_deque(void);
 void _starpu_destroy_deque(struct _starpu_deque_jobq *deque);
 
 struct starpu_task *_starpu_deque_pop_task(struct _starpu_deque_jobq *deque_queue, int workerid);
-struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq *deque_queue, _starpu_pthread_mutex_t *sched_mutex, int workerid);
+struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq *deque_queue, starpu_pthread_mutex_t *sched_mutex, int workerid);
 
 unsigned _starpu_get_deque_njobs(struct _starpu_deque_jobq *deque_queue);
 int _starpu_get_deque_nprocessed(struct _starpu_deque_jobq *deque_queue);

src/sched_policies/eager_central_policy.c

@@ -27,7 +27,7 @@
 struct _starpu_eager_center_policy_data
 {
 	struct _starpu_fifo_taskq *fifo;
-	_starpu_pthread_mutex_t policy_mutex;
+	starpu_pthread_mutex_t policy_mutex;
 };
 
 static void initialize_eager_center_policy(unsigned sched_ctx_id)
@@ -63,7 +63,7 @@ static int push_task_eager_policy(struct starpu_task *task)
  {
 	unsigned sched_ctx_id = task->sched_ctx;
 	struct _starpu_eager_center_policy_data *data = (struct _starpu_eager_center_policy_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 
@@ -95,8 +95,8 @@ static int push_task_eager_policy(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
 	{
 		worker = workers->get_next(workers, &it);
-		_starpu_pthread_mutex_t *sched_mutex;
-		_starpu_pthread_cond_t *sched_cond;
+		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);
@@ -113,8 +113,8 @@ 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_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	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);

src/sched_policies/eager_central_priority_policy.c

@@ -45,7 +45,7 @@ struct _starpu_priority_taskq
 struct _starpu_eager_central_prio_data
 {
 	struct _starpu_priority_taskq *taskq;
-	_starpu_pthread_mutex_t policy_mutex;
+	starpu_pthread_mutex_t policy_mutex;
 };
 
 /*
@@ -110,7 +110,7 @@ static int _starpu_priority_push_task(struct starpu_task *task)
 	struct _starpu_priority_taskq *taskq = data->taskq;
 
 	/* if the context has no workers return */
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 	
@@ -144,8 +144,8 @@ static int _starpu_priority_push_task(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
 	{
 		worker = workers->get_next(workers, &it);
-		_starpu_pthread_mutex_t *sched_mutex;
-		_starpu_pthread_cond_t *sched_cond;
+		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);
@@ -181,8 +181,8 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 	VALGRIND_HG_MUTEX_UNLOCK_POST(&data->policy_mutex);
 
 	/* release this mutex before trying to wake up other workers */
-	_starpu_pthread_mutex_t *curr_sched_mutex;
-	_starpu_pthread_cond_t *curr_sched_cond;
+	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);
 	
@@ -234,8 +234,8 @@ static struct starpu_task *_starpu_priority_pop_task(unsigned sched_ctx_id)
 			worker = workers->get_next(workers, &it);
 			if(worker != workerid)
 			{
-				_starpu_pthread_mutex_t *sched_mutex;
-				_starpu_pthread_cond_t *sched_cond;
+				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);

src/sched_policies/parallel_eager.c

@@ -153,7 +153,7 @@ static void deinitialize_peager_policy(unsigned sched_ctx_id)
 static int push_task_peager_policy(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 	
@@ -181,8 +181,8 @@ static int push_task_peager_policy(struct starpu_task *task)
 		/* If this is not a CPU, then the worker simply grabs tasks from the fifo */
 		if (starpu_worker_get_type(worker) != STARPU_CPU_WORKER  || master == worker)
 		{
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			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);
 		}
@@ -199,8 +199,8 @@ static int push_task_peager_policy(struct starpu_task *task)
 		/* If this is not a CPU, then the worker simply grabs tasks from the fifo */
 		if (starpu_worker_get_type(worker) != STARPU_CPU_WORKER  || master == worker)
 		{
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			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);
@@ -289,8 +289,8 @@ static struct starpu_task *pop_task_peager_policy(unsigned sched_ctx_id)
 				struct starpu_task *alias = _starpu_create_task_alias(task);
 				int local_worker = combined_workerid[i];
 				
-				_starpu_pthread_mutex_t *sched_mutex;
-				_starpu_pthread_cond_t *sched_cond;
+				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);

src/sched_policies/parallel_heft.c

@@ -47,7 +47,7 @@ struct _starpu_pheft_data
 	double idle_power;
 /* When we push a task on a combined worker we need all the cpu workers it contains
  * to be locked at once */
-	_starpu_pthread_mutex_t global_push_mutex;
+	starpu_pthread_mutex_t global_push_mutex;
 };
 
 static double worker_exp_start[STARPU_NMAXWORKERS];
@@ -72,8 +72,8 @@ static void parallel_heft_pre_exec_hook(struct starpu_task *task)
 	if (isnan(model))
 		model = 0.0;
 
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 	/* Once we have executed the task, we can update the predicted amount
 	 * of work. */
@@ -106,8 +106,8 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 		task->predicted = exp_end_predicted - worker_exp_end[best_workerid];
 		/* TODO */
 		task->predicted_transfer = 0;
-		_starpu_pthread_mutex_t *sched_mutex;
-		_starpu_pthread_cond_t *sched_cond;
+		starpu_pthread_mutex_t *sched_mutex;
+		starpu_pthread_cond_t *sched_cond;
 		starpu_worker_get_sched_condition(best_workerid, &sched_mutex, &sched_cond);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
@@ -160,8 +160,8 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 			alias->predicted = exp_end_predicted - worker_exp_end[local_worker];
 			/* TODO */
 			alias->predicted_transfer = 0;
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			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);
 			worker_exp_len[local_worker] += alias->predicted;
@@ -185,8 +185,8 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 
 static double compute_expected_end(int workerid, double length)
 {
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 
@@ -234,8 +234,8 @@ static double compute_expected_end(int workerid, double length)
 static double compute_ntasks_end(int workerid)
 {
 	enum starpu_perf_archtype perf_arch = starpu_worker_get_perf_archtype(workerid);
-	_starpu_pthread_mutex_t *sched_mutex;
-	_starpu_pthread_cond_t *sched_cond;
+	starpu_pthread_mutex_t *sched_mutex;
+	starpu_pthread_cond_t *sched_cond;
 
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 
@@ -321,8 +321,8 @@ static int _parallel_heft_push_task(struct starpu_task *task, unsigned prio, uns
 
 		if(!starpu_worker_is_combined_worker(worker))
 		{
-			_starpu_pthread_mutex_t *sched_mutex;
-			_starpu_pthread_cond_t *sched_cond;
+			starpu_pthread_mutex_t *sched_mutex;
+			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);
@@ -489,7 +489,7 @@ static int _parallel_heft_push_task(struct starpu_task *task, unsigned prio, uns
 static int parallel_heft_push_task(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
 	int ret_val = -1;
 

src/sched_policies/random_policy.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
  *
  * 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
@@ -84,7 +84,7 @@ static int _random_push_task(struct starpu_task *task, unsigned prio)
 static int random_push_task(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
 	unsigned nworkers;
         int ret_val = -1;
 

src/sched_policies/stack_queues.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2012  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
@@ -57,7 +57,7 @@ unsigned _starpu_get_stack_nprocessed(struct _starpu_stack_jobq *stack_queue)
 	return stack_queue->nprocessed;
 }
 
-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)
+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);
 	total_number_of_jobs++;
@@ -73,7 +73,7 @@ void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, _starpu_pth
 	_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)))
+struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queue, starpu_pthread_mutex_t *sched_mutex, int workerid __attribute__ ((unused)))
 {
 	struct _starpu_job *j = NULL;
 

src/sched_policies/stack_queues.h

@@ -42,9 +42,9 @@ struct _starpu_stack_jobq
 
 struct _starpu_stack_jobq *_starpu_create_stack(void);
 
-void _starpu_stack_push_task(struct _starpu_stack_jobq *stack, _starpu_pthread_mutex_t *sched_mutex, _starpu_pthread_cond_t *sched_cond, struct _starpu_job *task);
+void _starpu_stack_push_task(struct _starpu_stack_jobq *stack, starpu_pthread_mutex_t *sched_mutex, starpu_pthread_cond_t *sched_cond, struct _starpu_job *task);
 
-struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack, _starpu_pthread_mutex_t *sched_mutex, int workerid);
+struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack, starpu_pthread_mutex_t *sched_mutex, int workerid);
 
 void _starpu_init_stack_queues_mechanisms(void);
 

src/sched_policies/work_stealing_policy.c

@@ -59,8 +59,8 @@ static unsigned select_victim_round_robin(unsigned sched_ctx_id)
 	unsigned worker = ws->last_pop_worker;
 	unsigned nworkers = starpu_sched_ctx_get_nworkers(sched_ctx_id);
 
-	_starpu_pthread_mutex_t *victim_sched_mutex;
-	_starpu_pthread_cond_t *victim_sched_cond;
+	starpu_pthread_mutex_t *victim_sched_mutex;
+	starpu_pthread_cond_t *victim_sched_cond;
 
 	/* If the worker's queue is empty, let's try
 	 * the next ones */
@@ -280,8 +280,8 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 		q->njobs--;
 		return task;
 	}
-	_starpu_pthread_mutex_t *worker_sched_mutex;
-	_starpu_pthread_cond_t *worker_sched_cond;
+	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);
        
@@ -289,8 +289,8 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 	/* we need to steal someone's job */
 	unsigned victim = select_victim(sched_ctx_id);
 
-	_starpu_pthread_mutex_t *victim_sched_mutex;
-	_starpu_pthread_cond_t *victim_sched_cond;
+	starpu_pthread_mutex_t *victim_sched_mutex;
+	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);
@@ -336,7 +336,7 @@ int ws_push_task(struct starpu_task *task)
 	struct _starpu_job *j = _starpu_get_job_associated_to_task(task);
 	int workerid = starpu_worker_get_id();
 
-	_starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
+	starpu_pthread_mutex_t *changing_ctx_mutex = starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx_id);
         unsigned nworkers;
         int ret_val = -1;
 
@@ -358,8 +358,8 @@ int ws_push_task(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
 	{
 		worker = workers->get_next(workers, &it);
-		_starpu_pthread_mutex_t *sched_mutex;
-		_starpu_pthread_cond_t *sched_cond;
+		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);
 	}
@@ -387,8 +387,8 @@ int ws_push_task(struct starpu_task *task)
 	while(workers->has_next(workers, &it))
 	{
 		worker = workers->get_next(workers, &it);
-		_starpu_pthread_mutex_t *sched_mutex;
-		_starpu_pthread_cond_t *sched_cond;
+		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);

src/top/starpu_top.c

@@ -24,9 +24,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
-#include <pthread.h>
 #include <common/timing.h>
-#include <common/utils.h>
+#include <common/thread.h>
 #include <common/config.h>
 
 extern struct _starpu_top_message_queue*  _starpu_top_mt;
@@ -40,8 +39,8 @@ struct starpu_top_data** starpu_top_datas;
 struct starpu_top_param** starpu_top_params;
 
 sem_t starpu_top_wait_for_go;
-_starpu_pthread_mutex_t starpu_top_wait_for_continue_mutex;
-_starpu_pthread_cond_t starpu_top_wait_for_continue_cond = _STARPU_PTHREAD_COND_INITIALIZER;
+starpu_pthread_mutex_t starpu_top_wait_for_continue_mutex;
+starpu_pthread_cond_t starpu_top_wait_for_continue_cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 #undef _starpu_top_status_get
 int _starpu_top_status_get(void)

src/top/starpu_top_connection.c

@@ -100,9 +100,9 @@ void * message_to_ui(void * p)
 
 void _starpu_top_communications_threads_launcher(void)
 {
-	pthread_t from_ui;
-	pthread_t to_ui;
-	pthread_attr_t threads_attr;
+	starpu_pthread_t from_ui;
+	starpu_pthread_t to_ui;
+	starpu_pthread_attr_t threads_attr;
 
 
 	//Connection to UI & Socket Initilization
@@ -159,8 +159,8 @@ void _starpu_top_communications_threads_launcher(void)
 
 	//Threads creation
 	fprintf(stderr,"Threads Creation\n");
-	pthread_attr_init(&threads_attr);
-	pthread_attr_setdetachstate(&threads_attr, PTHREAD_CREATE_DETACHED);
+	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);

src/top/starpu_top_message_queue.h

@@ -17,7 +17,6 @@
 
 #include <sys/types.h>
 #include <semaphore.h>
-#include <pthread.h>
 #include <common/thread.h>
 
 #ifndef __STARPU_TOP_MESSAGE_QUEUE_H__
@@ -34,7 +33,7 @@ struct _starpu_top_message_queue
 	struct _starpu_top_message_queue_item* head;
 	struct _starpu_top_message_queue_item* tail;
 	sem_t semaphore;
-	_starpu_pthread_mutex_t mutex;
+	starpu_pthread_mutex_t mutex;
 };
 
 

tests/datawizard/dsm_stress.c

@@ -20,7 +20,6 @@
 #include <errno.h>
 #include <starpu.h>
 #include <stdlib.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -32,8 +31,8 @@
 
 #define VECTORSIZE	1024
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 static unsigned finished = 0;
 

tests/datawizard/mpi_like.c

@@ -18,25 +18,25 @@
 #include <config.h>
 #include <starpu.h>
 #include <errno.h>
-#include <pthread.h>
 #include "../helper.h"
+#warning enlever la ligne ci dessous, aussi dans les autres fichiers en dehors de src
 #include <common/thread.h>
 
 #define NTHREADS	4
 #define NITER		2
 
-//static pthread_cond_t cond;
-//static pthread_mutex_t mutex;
+//static starpu_pthread_cond_t cond;
+//static starpu_pthread_mutex_t mutex;
 
 struct thread_data
 {
 	unsigned index;
 	unsigned val;
 	starpu_data_handle_t handle;
-	pthread_t thread;
+	starpu_pthread_t thread;
 
-	_starpu_pthread_cond_t recv_cond;
-	_starpu_pthread_mutex_t recv_mutex;
+	starpu_pthread_cond_t recv_cond;
+	starpu_pthread_mutex_t recv_mutex;
 	unsigned recv_flag; // set when a message is received
 	unsigned recv_buf;
 	struct thread_data *neighbour;
@@ -199,14 +199,14 @@ int main(int argc, char **argv)
 
 	for (t = 0; t < NTHREADS; t++)
 	{
-		ret = pthread_create(&problem_data[t].thread, NULL, thread_func, &problem_data[t]);
+		ret = starpu_pthread_create(&problem_data[t].thread, NULL, thread_func, &problem_data[t]);
 		STARPU_ASSERT(!ret);
 	}
 
 	for (t = 0; t < NTHREADS; t++)
 	{
 		void *retval;
-		ret = pthread_join(problem_data[t].thread, &retval);
+		ret = starpu_pthread_join(problem_data[t].thread, &retval);
 		STARPU_ASSERT(!ret);
 		STARPU_ASSERT(retval == NULL);
 	}

tests/datawizard/mpi_like_async.c

@@ -17,7 +17,6 @@
 
 #include <config.h>
 #include <starpu.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -34,17 +33,17 @@ static unsigned niter = NITER_DEFAULT;
 
 //#define DEBUG_MESSAGES	1
 
-//static pthread_cond_t cond;
-//static pthread_mutex_t mutex;
+//static starpu_pthread_cond_t cond;
+//static starpu_pthread_mutex_t mutex;
 
 struct thread_data
 {
 	unsigned index;
 	unsigned val;
 	starpu_data_handle_t handle;
-	pthread_t thread;
+	starpu_pthread_t thread;
 
-	_starpu_pthread_mutex_t recv_mutex;
+	starpu_pthread_mutex_t recv_mutex;
 	unsigned recv_flag; // set when a message is received
 	unsigned recv_buf;
 	struct thread_data *neighbour;
@@ -57,8 +56,8 @@ struct data_req
 	struct data_req *next;
 };
 
-static _starpu_pthread_mutex_t data_req_mutex;
-static _starpu_pthread_cond_t data_req_cond;
+static starpu_pthread_mutex_t data_req_mutex;
+static starpu_pthread_cond_t data_req_cond;
 struct data_req *data_req_list;
 unsigned progress_thread_running;
 
@@ -331,7 +330,7 @@ int main(int argc, char **argv)
 #endif
 
 	/* Create a thread to perform blocking calls */
-	pthread_t progress_thread;
+	starpu_pthread_t progress_thread;
 	_STARPU_PTHREAD_MUTEX_INIT(&data_req_mutex, NULL);
 	_STARPU_PTHREAD_COND_INIT(&data_req_cond, NULL);
 	data_req_list = NULL;
@@ -347,7 +346,7 @@ int main(int argc, char **argv)
 		problem_data[t].neighbour = &problem_data[(t+1)%nthreads];
 	}
 
-	pthread_create(&progress_thread, NULL, progress_func, NULL);
+	starpu_pthread_create(&progress_thread, NULL, progress_func, NULL);
 
 	_STARPU_PTHREAD_MUTEX_LOCK(&data_req_mutex);
 	while (!progress_thread_running)
@@ -356,13 +355,13 @@ int main(int argc, char **argv)
 
 	for (t = 0; t < nthreads; t++)
 	{
-		ret = pthread_create(&problem_data[t].thread, NULL, thread_func, &problem_data[t]);
+		ret = starpu_pthread_create(&problem_data[t].thread, NULL, thread_func, &problem_data[t]);
 		STARPU_ASSERT(!ret);
 	}
 
 	for (t = 0; t < nthreads; t++)
 	{
-		ret = pthread_join(problem_data[t].thread, &retval);
+		ret = starpu_pthread_join(problem_data[t].thread, &retval);
 		STARPU_ASSERT(!ret);
 		STARPU_ASSERT(retval == NULL);
 	}
@@ -372,7 +371,7 @@ int main(int argc, char **argv)
 	_STARPU_PTHREAD_COND_SIGNAL(&data_req_cond);
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&data_req_mutex);
 
-	ret = pthread_join(progress_thread, &retval);
+	ret = starpu_pthread_join(progress_thread, &retval);
 	STARPU_ASSERT(!ret);
 	STARPU_ASSERT(retval == NULL);
 

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -20,7 +20,6 @@
 #include <errno.h>
 #include <starpu.h>
 #include <stdlib.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -66,8 +65,8 @@ int use_handle(starpu_data_handle_t handle)
 	return ret;
 }
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))

tests/datawizard/sync_with_data_with_mem_non_blocking_implicit.c

@@ -20,7 +20,6 @@
 #include <errno.h>
 #include <starpu.h>
 #include <stdlib.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -66,8 +65,8 @@ int use_handle(starpu_data_handle_t handle)
 	return ret;
 }
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 static unsigned n_synced_buffers;
 
 void callback_sync_data(void *arg __attribute__ ((unused)))

tests/experiments/latency/cuda_latency.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * 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
@@ -14,7 +14,6 @@
  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  */
 
-#include <pthread.h>
 #include <stdio.h>
 #include <cuda.h>
 #include <cuda_runtime.h>
@@ -22,24 +21,24 @@
 #include <sys/types.h>
 #include <sys/time.h>
 
-static pthread_t thread[2];
+static starpu_pthread_t thread[2];
 static unsigned thread_is_initialized[2];
 
-static _starpu_pthread_cond_t cond;
-static _starpu_pthread_mutex_t mutex;
+static starpu_pthread_cond_t cond;
+static starpu_pthread_mutex_t mutex;
 
 static size_t buffer_size = 4;
 static void *cpu_buffer;
 static void *gpu_buffer[2];
 
-static pthread_cond_t cond_go;
+static starpu_pthread_cond_t cond_go;
 static unsigned ready = 0;
 static unsigned nready_gpu = 0;
 
 static unsigned niter = 250000;
 
-static _starpu_pthread_cond_t cond_gpu;
-static _starpu_pthread_mutex_t mutex_gpu;
+static starpu_pthread_cond_t cond_gpu;
+static starpu_pthread_mutex_t mutex_gpu;
 static unsigned data_is_available[2];
 
 static cudaStream_t stream[2];
@@ -172,7 +171,7 @@ int main(int argc, char **argv)
 	for (id = 0; id < 2; id++)
 	{
 		thread_is_initialized[id] = 0;
-		pthread_create(&thread[0], NULL, launch_gpu_thread, &id);
+		starpu_pthread_create(&thread[0], NULL, launch_gpu_thread, &id);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(&mutex);
 		while (!thread_is_initialized[id])

tests/main/driver_api/run_driver.c

@@ -15,7 +15,6 @@
  */
 
 #include <starpu.h>
-#include <pthread.h>
 
 #include "../../helper.h"
 
@@ -63,7 +62,7 @@ static int
 test_cpu(void)
 {
 	int ret, var = 0;
-	static pthread_t driver_thread;
+	static starpu_pthread_t driver_thread;
 	struct starpu_conf conf;
 	struct starpu_driver d =
 	{
@@ -82,7 +81,7 @@ test_cpu(void)
 		return STARPU_TEST_SKIPPED;
 	}
 
-	ret = pthread_create(&driver_thread, NULL, run_driver, &d);
+	ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d);
 	if (ret != 0)
 	{
 		ret = 1;
@@ -108,7 +107,7 @@ test_cpu(void)
 
 out:
 	starpu_drivers_request_termination();
-	if (pthread_join(driver_thread, NULL) != 0)
+	if (starpu_pthread_join(driver_thread, NULL) != 0)
 		return 1;
 	starpu_shutdown();
 	return ret;
@@ -120,7 +119,7 @@ static int
 test_cuda(void)
 {
 	int ret, var = 0;
-	static pthread_t driver_thread;
+	static starpu_pthread_t driver_thread;
 	struct starpu_conf conf;
 	struct starpu_driver d =
 	{
@@ -139,7 +138,7 @@ test_cuda(void)
 		return STARPU_TEST_SKIPPED;
 	}
 
-	ret = pthread_create(&driver_thread, NULL, run_driver, &d);
+	ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d);
 	if (ret == -1)
 	{
 		ret = 1;
@@ -165,7 +164,7 @@ test_cuda(void)
 
 out:
 	starpu_drivers_request_termination();
-	if (pthread_join(driver_thread, NULL) != 0)
+	if (starpu_pthread_join(driver_thread, NULL) != 0)
 		return 1;
 	starpu_shutdown();
 	return ret;
@@ -177,7 +176,7 @@ static int
 test_opencl(void)
 {
 	int ret, var = 0;
-	static pthread_t driver_thread;
+	static starpu_pthread_t driver_thread;
 	struct starpu_conf conf;
 
 	cl_int err;
@@ -222,7 +221,7 @@ test_opencl(void)
 		return STARPU_TEST_SKIPPED;
 	}
 
-	ret = pthread_create(&driver_thread, NULL, run_driver, &d);
+	ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d);
 	if (ret == -1)
 	{
 		ret = 1;
@@ -248,7 +247,7 @@ test_opencl(void)
 
 out:
 	starpu_drivers_request_termination();
-	if (pthread_join(driver_thread, NULL) != 0)
+	if (starpu_pthread_join(driver_thread, NULL) != 0)
 		return 1;
 	starpu_shutdown();
 	return ret;

tests/main/execute_on_a_specific_worker.c

@@ -20,7 +20,6 @@
 #include <errno.h>
 #include <starpu.h>
 #include <stdlib.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -32,8 +31,8 @@
 
 #define VECTORSIZE	1024
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 static unsigned finished = 0;
 

tests/main/multithreaded.c

@@ -17,15 +17,13 @@
  */
 
 #include <sys/time.h>
-#include <pthread.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <pthread.h>
 
 #include <starpu.h>
 #include "../helper.h"
 
-pthread_t threads[16];
+starpu_pthread_t threads[16];
 
 #ifdef STARPU_QUICK_CHECK
 static unsigned ntasks = 64;
@@ -116,13 +114,13 @@ int main(int argc, char **argv)
 	unsigned t;
 	for (t = 0; t < nthreads; t++)
 	{
-		ret = pthread_create(&threads[t], NULL, thread_func, NULL);
+		ret = starpu_pthread_create(&threads[t], NULL, thread_func, NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 
 	for (t = 0; t < nthreads; t++)
 	{
-		ret = pthread_join(threads[t], NULL);
+		ret = starpu_pthread_join(threads[t], NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 

tests/main/multithreaded_init.c

@@ -16,7 +16,6 @@
  */
 #include <sys/time.h>
 #include <stdio.h>
-#include <pthread.h>
 #include <starpu.h>
 #include "../helper.h"
 
@@ -47,19 +46,19 @@ int main(int argc, char **argv)
 	struct timeval start;
 	struct timeval end;
 
-	pthread_t threads[NUM_THREADS];
+	starpu_pthread_t threads[NUM_THREADS];
 
 	gettimeofday(&start, NULL);
 
 	for (i = 0; i < NUM_THREADS; ++i)
 	{
-		int ret = pthread_create(&threads[i], NULL, launch_starpu, NULL);
+		int ret = starpu_pthread_create(&threads[i], NULL, launch_starpu, NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 
 	for (i = 0; i < NUM_THREADS; ++i)
 	{
-		int ret = pthread_join(threads[i], NULL);
+		int ret = starpu_pthread_join(threads[i], NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 
@@ -73,13 +72,13 @@ int main(int argc, char **argv)
 
 	for (i = 0; i < NUM_THREADS; i++)
 	{
-		int ret = pthread_create(&threads[i], NULL, shutdown_starpu, NULL);
+		int ret = starpu_pthread_create(&threads[i], NULL, shutdown_starpu, NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 
 	for (i = 0; i < NUM_THREADS; i++)
 	{
-		int ret = pthread_join(threads[i], NULL);
+		int ret = starpu_pthread_join(threads[i], NULL);
 		STARPU_ASSERT(ret == 0);
 	}
 

tests/main/regenerate.c

@@ -18,7 +18,6 @@
 #include <sys/time.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <pthread.h>
 #include <starpu.h>
 #include "../helper.h"
 #include <common/thread.h>
@@ -31,8 +30,8 @@ static unsigned ntasks = 65536;
 static unsigned cnt = 0;
 
 static unsigned completed = 0;
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 static void callback(void *arg __attribute__ ((unused)))
 {

tests/main/subgraph_repeat.c

@@ -17,7 +17,6 @@
 
 #include <sys/time.h>
 #include <starpu.h>
-#include <pthread.h>
 #include <common/thread.h>
 
 #include "../helper.h"
@@ -47,8 +46,8 @@ static struct starpu_task taskA, taskB, taskC, taskD;
 
 static unsigned loop_cnt = 0;
 static unsigned check_cnt = 0;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {

tests/main/subgraph_repeat_regenerate.c

@@ -17,7 +17,6 @@
 
 #include <sys/time.h>
 #include <starpu.h>
-#include <pthread.h>
 #include <common/thread.h>
 
 #include "../helper.h"
@@ -47,8 +46,8 @@ static struct starpu_task taskA, taskB, taskC, taskD;
 
 static unsigned loop_cnt = 0;
 static unsigned check_cnt = 0;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {

tests/main/subgraph_repeat_regenerate_tag.c

@@ -17,7 +17,6 @@
 
 #include <sys/time.h>
 #include <starpu.h>
-#include <pthread.h>
 #include <common/thread.h>
 
 #include "../helper.h"
@@ -53,8 +52,8 @@ static struct starpu_task taskA, taskB, taskC, taskD;
 
 static unsigned loop_cnt = 0;
 static unsigned check_cnt = 0;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {

tests/main/subgraph_repeat_tag.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
  *
  * 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
@@ -17,7 +17,6 @@
 
 #include <sys/time.h>
 #include <starpu.h>
-#include <pthread.h>
 
 #include "../helper.h"
 
@@ -46,8 +45,8 @@ static struct starpu_task taskA, taskB, taskC, taskD;
 
 static unsigned loop_cnt = 0;
 static unsigned check_cnt = 0;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {

tests/overlap/overlap.c

@@ -22,7 +22,6 @@
 #include <errno.h>
 #include <starpu.h>
 #include <stdlib.h>
-#include <pthread.h>
 #include "../helper.h"
 #include <common/thread.h>
 
@@ -36,8 +35,8 @@
 
 #define SYMBOL	"sleep"
 
-static _starpu_pthread_mutex_t mutex = _STARPU_PTHREAD_MUTEX_INITIALIZER;
-static _starpu_pthread_cond_t cond = _STARPU_PTHREAD_COND_INITIALIZER;
+static starpu_pthread_mutex_t mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
+static starpu_pthread_cond_t cond = STARPU_PTHREAD_COND_INITIALIZER;
 
 static unsigned finished = 0;
 static unsigned cnt = NTASKS;