pass pthread types through typedefs

src/common/barrier.h

@@ -18,15 +18,16 @@
 #define __COMMON_BARRIER_H__
 
 #include <pthread.h>
+#include <common/utils.h>
 
 struct _starpu_barrier
 {
 	int count;
 	int reached_start;
 	int reached_exit;
-	pthread_mutex_t mutex;
-	pthread_mutex_t mutex_exit;
-	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);
@@ -37,7 +38,7 @@ int _starpu_barrier_wait(struct _starpu_barrier *barrier);
 
 #if !defined(PTHREAD_BARRIER_SERIAL_THREAD)
 #  define PTHREAD_BARRIER_SERIAL_THREAD -1
-#  define pthread_barrier_t struct _starpu_barrier
+#  define _starpu_pthread_barrier_t struct _starpu_barrier
 #  define pthread_barrier_init(b,a,c) _starpu_barrier_init(b, c)
 #  define pthread_barrier_destroy(b) _starpu_barrier_destroy(b)
 #  define pthread_barrier_wait(b) _starpu_barrier_wait(b)

src/common/starpu_spinlock.c

@@ -88,7 +88,7 @@ int _starpu_spin_lock(struct _starpu_spinlock *lock)
 int _starpu_spin_checklocked(struct _starpu_spinlock *lock)
 {
 #ifdef STARPU_SPINLOCK_CHECK
-	int ret = pthread_mutex_trylock(&lock->errcheck_lock);
+	int ret = _STARPU_PTHREAD_MUTEX_TRYLOCK(&lock->errcheck_lock);
 	STARPU_ASSERT(ret != 0);
 	return ret == 0;
 #else
@@ -106,7 +106,7 @@ int _starpu_spin_checklocked(struct _starpu_spinlock *lock)
 int _starpu_spin_trylock(struct _starpu_spinlock *lock)
 {
 #ifdef STARPU_SPINLOCK_CHECK
-	int ret = pthread_mutex_trylock(&lock->errcheck_lock);
+	int ret = _STARPU_PTHREAD_MUTEX_TRYLOCK(&lock->errcheck_lock);
 	STARPU_ASSERT(!ret || (ret == EBUSY));
 	return ret;
 #else

src/common/starpu_spinlock.h

@@ -27,10 +27,10 @@ struct _starpu_spinlock
 {
 #ifdef STARPU_SPINLOCK_CHECK
 	pthread_mutexattr_t errcheck_attr;
-	pthread_mutex_t errcheck_lock;
+	_starpu_pthread_mutex_t errcheck_lock;
 #else
 #ifdef HAVE_PTHREAD_SPIN_LOCK
-	pthread_spinlock_t lock;
+	_starpu_pthread_spinlock_t lock;
 #else
 	/* we only have a trivial implementation yet ! */
 	uint32_t taken __attribute__ ((aligned(16)));

src/common/utils.c

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

src/common/utils.h

@@ -23,7 +23,6 @@
 #include <sys/stat.h>
 #include <string.h>
 #include <pthread.h>
-#include <common/barrier.h>
 #include <stdlib.h>
 #include <math.h>
 
@@ -53,9 +52,10 @@
 
 #define _STARPU_IS_ZERO(a) (fpclassify(a) == FP_ZERO)
 
+typedef pthread_mutex_t _starpu_pthread_mutex_t;
 int _starpu_mkpath(const char *s, mode_t mode);
 void _starpu_mkpath_and_check(const char *s, mode_t mode);
-int _starpu_check_mutex_deadlock(pthread_mutex_t *mutex);
+int _starpu_check_mutex_deadlock(_starpu_pthread_mutex_t *mutex);
 char *_starpu_get_home_path(void);
 
 /* If FILE is currently on a comment line, eat it.  */
@@ -111,6 +111,8 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 	}                                                                      \
 } while (0)
 
+#define _STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) pthread_mutex_trylock(mutex)
+
 #define _STARPU_PTHREAD_MUTEX_UNLOCK(mutex) do {                               \
 	int p_ret = pthread_mutex_unlock(mutex);                               \
 	if (STARPU_UNLIKELY(p_ret)) {                                          \
@@ -121,6 +123,7 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 	}                                                                      \
 } while (0)
 
+typedef pthread_rwlock_t _starpu_pthread_rwlock_t;
 /*
  * Encapsulation of the pthread_rwlock_* functions.
  */
@@ -174,6 +177,7 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 	}                                                                      \
 } while (0)
 
+typedef pthread_cond_t _starpu_pthread_cond_t;
 /*
  * Encapsulation of the pthread_cond_* functions.
  */
@@ -227,6 +231,9 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 	}                                                                      \
 } while (0)
 
+#include <common/barrier.h>
+
+typedef pthread_barrier_t _starpu_pthread_barrier_t;
 /*
  * Encapsulation of the pthread_barrier_* functions.
  */
@@ -260,6 +267,7 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 	}                                                                      \
 } while (0)
 
+typedef pthread_spinlock_t _starpu_pthread_spinlock_t;
 /*
  * Encapsulation of the pthread_spin_* functions.
  */

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 pthread_mutex_t logfile_mutex = PTHREAD_MUTEX_INITIALIZER;
+static _starpu_pthread_mutex_t logfile_mutex = PTHREAD_MUTEX_INITIALIZER;
 static FILE *logfile;
 #endif
 

src/core/dependencies/cg.h

@@ -90,8 +90,8 @@ struct _starpu_cg
 		struct
 		{
 			unsigned completed;
-			pthread_mutex_t cg_mutex;
-			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

@@ -36,7 +36,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 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

@@ -37,6 +37,7 @@
 #include <core/perfmodel/perfmodel.h>
 #include <core/errorcheck.h>
 #include <common/barrier.h>
+#include <common/utils.h>
 
 #ifdef STARPU_USE_CUDA
 #include <cuda.h>
@@ -64,8 +65,8 @@ LIST_TYPE(_starpu_job,
 
 	/* These synchronization structures are used to wait for the job to be
 	 * available or terminated for instance. */
-	pthread_mutex_t sync_mutex;
-	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
@@ -132,8 +133,8 @@ LIST_TYPE(_starpu_job,
 	int active_task_alias_count;
 
 	/* Parallel workers may have to synchronize before/after the execution of a parallel task. */
-	pthread_barrier_t before_work_barrier;
-	pthread_barrier_t after_work_barrier;
+	_starpu_pthread_barrier_t before_work_barrier;
+	_starpu_pthread_barrier_t after_work_barrier;
 )
 
 /* Create an internal struct _starpu_job *structure to encapsulate the task. */

src/core/perfmodel/perfmodel_history.c

@@ -50,7 +50,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 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

@@ -30,7 +30,7 @@ struct progression_hook
 };
 
 /* protect the hook table */
-static 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/task.c

@@ -32,8 +32,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 pthread_cond_t submitted_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t submitted_mutex = PTHREAD_MUTEX_INITIALIZER;
+static _starpu_pthread_cond_t submitted_cond = PTHREAD_COND_INITIALIZER;
+static _starpu_pthread_mutex_t submitted_mutex = PTHREAD_MUTEX_INITIALIZER;
 static long int nsubmitted = 0, nready = 0;
 
 static void _starpu_increment_nsubmitted_tasks(void);

src/core/task_bundle.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009, 2010-2011  Université de Bordeaux 1
+ * Copyright (C) 2009, 2010-2012  Université de Bordeaux 1
  * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  * Copyright (C) 2012 Inria
  *
@@ -23,6 +23,8 @@
 #  include <pthread.h>
 #endif
 
+#include <common/utils.h>
+
 /* struct _starpu_task_bundle_entry
  * ================================
  * Purpose
@@ -68,7 +70,7 @@ struct _starpu_task_bundle
 #if defined(_MSC_VER)
 	void *mutex;
 #else
-	pthread_mutex_t mutex;
+	_starpu_pthread_mutex_t mutex;
 #endif
 
 	struct _starpu_task_bundle_entry *list;

src/core/workers.c

@@ -37,8 +37,8 @@
 #endif
 
 /* acquire/release semantic for concurrent initialization/de-initialization */
-static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
+static _starpu_pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static _starpu_pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
 static int init_count = 0;
 static enum { UNINITIALIZED, CHANGING, INITIALIZED } initialized = UNINITIALIZED;
 
@@ -242,8 +242,8 @@ static struct _starpu_worker_set gordon_worker_set;
 
 static void _starpu_init_worker_queue(struct _starpu_worker *workerarg)
 {
-	pthread_cond_t *cond = workerarg->sched_cond;
-	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;
 
@@ -1133,7 +1133,7 @@ void _starpu_worker_set_status(int workerid, enum _starpu_worker_status status)
 	config.workers[workerid].status = status;
 }
 
-void starpu_worker_set_sched_condition(int workerid, pthread_cond_t *sched_cond, pthread_mutex_t *sched_mutex)
+void starpu_worker_set_sched_condition(int workerid, _starpu_pthread_cond_t *sched_cond, _starpu_pthread_mutex_t *sched_mutex)
 {
 	config.workers[workerid].sched_cond = sched_cond;
 	config.workers[workerid].sched_mutex = sched_mutex;

src/core/workers.h

@@ -56,7 +56,7 @@
 struct _starpu_worker
 {
 	struct _starpu_machine_config *config;
-        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 */
@@ -67,10 +67,10 @@ struct _starpu_worker
 	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 */
-        pthread_cond_t ready_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 ? */
-	pthread_cond_t *sched_cond; /* condition variable used when the worker waits for tasks. */
-	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 */
@@ -112,13 +112,13 @@ struct _starpu_combined_worker
  * accelerators (eg. Gordon for n SPUs) */
 struct _starpu_worker_set
 {
-        pthread_mutex_t mutex;
+        _starpu_pthread_mutex_t mutex;
 	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;
-        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;
 };
 
@@ -188,7 +188,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, pthread_cond_t *cond, 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.

src/datawizard/coherency.h

@@ -116,8 +116,8 @@ struct _starpu_data_state
 	unsigned busy_count;
 	/* Is starpu_data_unregister waiting for busy_count? */
 	unsigned busy_waiting;
-	pthread_mutex_t busy_mutex;
-	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 */
@@ -158,7 +158,7 @@ struct _starpu_data_state
 
 	/* This lock should protect any operation to enforce
 	 * sequential_consistency */
-	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/data_request.c

@@ -22,11 +22,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 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 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

@@ -423,8 +423,8 @@ struct _starpu_unregister_callback_arg
 	unsigned memory_node;
 	starpu_data_handle_t handle;
 	unsigned terminated;
-	pthread_mutex_t mutex;
-	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/memalloc.c

@@ -21,10 +21,10 @@
 #include <starpu_opencl.h>
 
 /* This per-node RW-locks protect mc_list and memchunk_cache entries */
-static pthread_rwlock_t mc_rwlock[STARPU_MAXNODES];
+static _starpu_pthread_rwlock_t mc_rwlock[STARPU_MAXNODES];
 
 /* This per-node RW-locks protect lru_list */
-static pthread_rwlock_t lru_rwlock[STARPU_MAXNODES];
+static _starpu_pthread_rwlock_t lru_rwlock[STARPU_MAXNODES];
 
 /* Last Recently used memory chunkgs */
 static struct _starpu_mem_chunk_lru_list *starpu_lru_list[STARPU_MAXNODES];

src/datawizard/memory_nodes.c

@@ -124,7 +124,7 @@ unsigned _starpu_register_memory_node(enum starpu_node_kind kind, int devid)
 /* 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(pthread_cond_t *cond, 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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2011  Université de Bordeaux 1
+ * Copyright (C) 2009-2012  Université de Bordeaux 1
  * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -22,6 +22,7 @@
 #include <common/config.h>
 #include <datawizard/coherency.h>
 #include <datawizard/memalloc.h>
+#include <common/utils.h>
 
 
 #define _STARPU_MEMORY_NODE_TUPLE(node1,node2) (node1 | (node2 << 4))
@@ -30,8 +31,8 @@
 
 struct _starpu_cond_and_mutex
 {
-        pthread_cond_t *cond;
-        pthread_mutex_t *mutex;
+        _starpu_pthread_cond_t *cond;
+        _starpu_pthread_mutex_t *mutex;
 };
 
 struct _starpu_mem_node_descr
@@ -50,7 +51,7 @@ struct _starpu_mem_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. */
-	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 */
@@ -67,7 +68,7 @@ void _starpu_memory_node_worker_add(unsigned node);
 unsigned _starpu_memory_node_workers(unsigned node);
 unsigned _starpu_register_memory_node(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(pthread_cond_t *cond, 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);
 
 enum starpu_node_kind _starpu_node_get_kind(uint32_t node);
 int _starpu_memory_node_to_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;
-	pthread_cond_t cond;
-	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

@@ -31,8 +31,8 @@ static unsigned progress_thread_is_inited = 0;
 
 pthread_t progress_thread;
 
-pthread_cond_t progress_cond;
-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

@@ -29,7 +29,7 @@
 #include "driver_opencl_utils.h"
 #include <common/utils.h>
 
-static pthread_mutex_t big_lock = PTHREAD_MUTEX_INITIALIZER;
+static _starpu_pthread_mutex_t big_lock = PTHREAD_MUTEX_INITIALIZER;
 
 static cl_context contexts[STARPU_MAXOPENCLDEVS];
 static cl_device_id devices[STARPU_MAXOPENCLDEVS];

src/profiling/bound.c

@@ -116,7 +116,7 @@ int _starpu_bound_recording;
 static int recorddeps;
 static int recordprio;
 
-static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+static _starpu_pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void starpu_bound_start(int deps, int prio)
 {

src/profiling/profiling.c

@@ -26,7 +26,7 @@
 #include <errno.h>
 
 static struct starpu_worker_profiling_info worker_info[STARPU_NMAXWORKERS];
-static 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

@@ -38,8 +38,8 @@
 static unsigned nworkers;
 static struct _starpu_fifo_taskq *queue_array[STARPU_NMAXWORKERS];
 
-static pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
-static pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
+static _starpu_pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
+static _starpu_pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
 
 static double alpha = _STARPU_DEFAULT_ALPHA;
 static double beta = _STARPU_DEFAULT_BETA;

src/sched_policies/deque_queues.c

@@ -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, 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, 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

@@ -26,8 +26,8 @@
 /* the former is the actual queue, the latter some container */
 static struct _starpu_fifo_taskq *fifo;
 
-static pthread_cond_t sched_cond;
-static pthread_mutex_t sched_mutex;
+static _starpu_pthread_cond_t sched_cond;
+static _starpu_pthread_mutex_t sched_mutex;
 
 static void initialize_eager_center_policy(struct starpu_machine_topology *topology,
 		   __attribute__ ((unused)) struct starpu_sched_policy *_policy)

src/sched_policies/eager_central_priority_policy.c

@@ -46,8 +46,8 @@ static struct _starpu_priority_taskq *taskq;
 
 /* keep track of the total number of tasks to be scheduled to avoid infinite
  * polling when there are really few tasks in the overall queue */
-static pthread_cond_t global_sched_cond;
-static pthread_mutex_t global_sched_mutex;
+static _starpu_pthread_cond_t global_sched_cond;
+static _starpu_pthread_mutex_t global_sched_mutex;
 
 /*
  * Centralized queue with priorities

src/sched_policies/fifo_queues.c

@@ -54,8 +54,8 @@ int _starpu_fifo_empty(struct _starpu_fifo_taskq *fifo)
 
 int
 _starpu_fifo_push_sorted_task(struct _starpu_fifo_taskq *fifo_queue,
-			      pthread_mutex_t *sched_mutex,
-			      pthread_cond_t *sched_cond,
+			      _starpu_pthread_mutex_t *sched_mutex,
+			      _starpu_pthread_cond_t *sched_cond,
 			      struct starpu_task *task)
 {
 	struct starpu_task_list *list = &fifo_queue->taskq;
@@ -124,7 +124,7 @@ _starpu_fifo_push_sorted_task(struct _starpu_fifo_taskq *fifo_queue,
 }
 
 /* TODO: revert front/back? */
-int _starpu_fifo_push_task(struct _starpu_fifo_taskq *fifo_queue, pthread_mutex_t *sched_mutex, pthread_cond_t *sched_cond, struct starpu_task *task)
+int _starpu_fifo_push_task(struct _starpu_fifo_taskq *fifo_queue, _starpu_pthread_mutex_t *sched_mutex, _starpu_pthread_cond_t *sched_cond, struct starpu_task *task)
 {
 
 	if (task->priority > 0)
@@ -193,7 +193,7 @@ struct starpu_task *_starpu_fifo_pop_local_task(struct _starpu_fifo_taskq *fifo_
 }
 
 /* pop every task that can be executed on the calling driver */
-struct starpu_task *_starpu_fifo_pop_every_task(struct _starpu_fifo_taskq *fifo_queue, pthread_mutex_t *sched_mutex, int workerid)
+struct starpu_task *_starpu_fifo_pop_every_task(struct _starpu_fifo_taskq *fifo_queue, _starpu_pthread_mutex_t *sched_mutex, int workerid)
 {
 	struct starpu_task_list *old_list;
 	unsigned size;

src/sched_policies/fifo_queues.h

@@ -21,6 +21,7 @@
 
 #include <starpu.h>
 #include <common/config.h>
+#include <common/utils.h>
 
 struct _starpu_fifo_taskq
 {
@@ -45,14 +46,14 @@ void _starpu_destroy_fifo(struct _starpu_fifo_taskq *fifo);
 int _starpu_fifo_empty(struct _starpu_fifo_taskq *fifo);
 
 int _starpu_fifo_push_sorted_task(struct _starpu_fifo_taskq *fifo_queue,
-				  pthread_mutex_t *sched_mutex,
-				  pthread_cond_t *sched_cond,
+				  _starpu_pthread_mutex_t *sched_mutex,
+				  _starpu_pthread_cond_t *sched_cond,
 				  struct starpu_task *task);
 
-int _starpu_fifo_push_task(struct _starpu_fifo_taskq *fifo, pthread_mutex_t *sched_mutex, pthread_cond_t *sched_cond, struct starpu_task *task);
+int _starpu_fifo_push_task(struct _starpu_fifo_taskq *fifo, _starpu_pthread_mutex_t *sched_mutex, _starpu_pthread_cond_t *sched_cond, struct starpu_task *task);
 
 struct starpu_task *_starpu_fifo_pop_task(struct _starpu_fifo_taskq *fifo, int workerid);
 struct starpu_task *_starpu_fifo_pop_local_task(struct _starpu_fifo_taskq *fifo);
-struct starpu_task *_starpu_fifo_pop_every_task(struct _starpu_fifo_taskq *fifo, pthread_mutex_t *sched_mutex, int workerid);
+struct starpu_task *_starpu_fifo_pop_every_task(struct _starpu_fifo_taskq *fifo, _starpu_pthread_mutex_t *sched_mutex, int workerid);
 
 #endif // __FIFO_QUEUES_H__

src/sched_policies/heft.c

@@ -41,8 +41,8 @@
 static unsigned nworkers;
 static struct _starpu_fifo_taskq *queue_array[STARPU_NMAXWORKERS];
 
-static pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
-static pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
+static _starpu_pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
+static _starpu_pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
 
 static double alpha = _STARPU_DEFAULT_ALPHA;
 static double beta = _STARPU_DEFAULT_BETA;

src/sched_policies/parallel_greedy.c

@@ -26,11 +26,11 @@ static struct _starpu_fifo_taskq *local_fifo[STARPU_NMAXWORKERS];
 
 static int master_id[STARPU_NMAXWORKERS];
 
-static pthread_cond_t sched_cond;
-static pthread_mutex_t sched_mutex;
+static _starpu_pthread_cond_t sched_cond;
+static _starpu_pthread_mutex_t sched_mutex;
 
-static pthread_cond_t master_sched_cond[STARPU_NMAXWORKERS];
-static pthread_mutex_t master_sched_mutex[STARPU_NMAXWORKERS];
+static _starpu_pthread_cond_t master_sched_cond[STARPU_NMAXWORKERS];
+static _starpu_pthread_mutex_t master_sched_mutex[STARPU_NMAXWORKERS];
 
 /* XXX instead of 10, we should use some "MAX combination .."*/
 static int possible_combinations_cnt[STARPU_NMAXWORKERS];

src/sched_policies/parallel_heft.c

@@ -38,12 +38,12 @@ static unsigned nworkers, ncombinedworkers;
 //static enum starpu_perf_archtype applicable_perf_archtypes[STARPU_NARCH_VARIATIONS];
 //static unsigned napplicable_perf_archtypes = 0;
 
-static pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
-static pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
+static _starpu_pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
+static _starpu_pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
 
 /* When we push a task on a combined worker we need all the cpu workers it contains
  * to be locked at once */
-static pthread_mutex_t global_push_mutex;
+static _starpu_pthread_mutex_t global_push_mutex;
 
 static double alpha = _STARPU_DEFAULT_ALPHA;
 static double beta = _STARPU_DEFAULT_BETA;

src/sched_policies/random_policy.c

@@ -23,8 +23,8 @@
 
 static unsigned nworkers;
 
-static pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
-static pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
+static _starpu_pthread_cond_t sched_cond[STARPU_NMAXWORKERS];
+static _starpu_pthread_mutex_t sched_mutex[STARPU_NMAXWORKERS];
 
 static int _random_push_task(struct starpu_task *task, unsigned prio)
 {

src/sched_policies/stack_queues.c

@@ -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, pthread_mutex_t *sched_mutex, 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++;
@@ -74,7 +74,7 @@ void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, pthread_mut
 	_STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
 }
 
-struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queue, 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, pthread_mutex_t *sched_mutex, 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, 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

@@ -28,8 +28,8 @@ static unsigned last_pop_worker;
 static unsigned last_push_worker;
 static struct _starpu_deque_jobq *queue_array[STARPU_NMAXWORKERS];
 
-static pthread_mutex_t global_sched_mutex;
-static pthread_cond_t global_sched_cond;
+static _starpu_pthread_mutex_t global_sched_mutex;
+static _starpu_pthread_cond_t global_sched_cond;
 
 /**
  * Keep track of the work performed from the beginning of the algorithm to make

src/top/starpu_top.c

@@ -39,8 +39,8 @@ struct starpu_top_data** starpu_top_datas;
 struct starpu_top_param** starpu_top_params;
 
 sem_t starpu_top_wait_for_go;
-pthread_mutex_t starpu_top_wait_for_continue_mutex;
-pthread_cond_t starpu_top_wait_for_continue_cond = PTHREAD_COND_INITIALIZER;
+_starpu_pthread_mutex_t starpu_top_wait_for_continue_mutex;
+_starpu_pthread_cond_t starpu_top_wait_for_continue_cond = PTHREAD_COND_INITIALIZER;
 
 #undef _starpu_top_status_get
 int _starpu_top_status_get(void)

src/top/starpu_top_message_queue.h

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