StarPU Handbook
starpu_thread_util.h
Go to the documentation of this file.
1 /* StarPU --- Runtime system for heterogeneous multicore architectures.
2  *
3  * Copyright (C) 2012-2013 Inria
4  * Copyright (C) 2010-2014,2016-2017 Université de Bordeaux
5  * Copyright (C) 2010-2013,2015 CNRS
6  *
7  * StarPU is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or (at
10  * your option) any later version.
11  *
12  * StarPU is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15  *
16  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
17  */
18 
19 #ifndef __STARPU_THREAD_UTIL_H__
20 #define __STARPU_THREAD_UTIL_H__
21 
22 #include <starpu_util.h>
23 #include <errno.h>
24 
25 #if !(defined(_MSC_VER) && !defined(BUILDING_STARPU))
26 /*
27  * Encapsulation of the starpu_pthread_create_* functions.
28  */
29 
30 #define STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, where) do { \
31  int p_ret = starpu_pthread_create_on((name), (thread), (attr), (routine), (arg), (where)); \
32  if (STARPU_UNLIKELY(p_ret != 0)) { \
33  fprintf(stderr, \
34  "%s:%d starpu_pthread_create_on: %s\n", \
35  __FILE__, __LINE__, strerror(p_ret)); \
36  STARPU_ABORT(); \
37  } \
38 } while (0)
39 
40 #define STARPU_PTHREAD_CREATE(thread, attr, routine, arg) do { \
41  int p_ret = starpu_pthread_create((thread), (attr), (routine), (arg)); \
42  if (STARPU_UNLIKELY(p_ret != 0)) { \
43  fprintf(stderr, \
44  "%s:%d starpu_pthread_create: %s\n", \
45  __FILE__, __LINE__, strerror(p_ret)); \
46  STARPU_ABORT(); \
47  } \
48 } while (0)
49 
50 /*
51  * Encapsulation of the starpu_pthread_mutex_* functions.
52  */
53 
54 #define STARPU_PTHREAD_MUTEX_INIT(mutex, attr) do { \
55  int p_ret = starpu_pthread_mutex_init((mutex), (attr)); \
56  if (STARPU_UNLIKELY(p_ret)) { \
57  fprintf(stderr, \
58  "%s:%d starpu_pthread_mutex_init: %s\n", \
59  __FILE__, __LINE__, strerror(p_ret)); \
60  STARPU_ABORT(); \
61  } \
62 } while (0)
63 
64 #define STARPU_PTHREAD_MUTEX_DESTROY(mutex) do { \
65  int p_ret = starpu_pthread_mutex_destroy(mutex); \
66  if (STARPU_UNLIKELY(p_ret)) { \
67  fprintf(stderr, \
68  "%s:%d starpu_pthread_mutex_destroy: %s\n", \
69  __FILE__, __LINE__, strerror(p_ret)); \
70  STARPU_ABORT(); \
71  } \
72 } while(0)
73 
74 #ifdef STARPU_DEBUG
75 #define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line) \
76  starpu_pthread_mutex_check_sched((mutex), file, line)
77 #else
78 #define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line)
79 #endif
80 
81 #define STARPU_PTHREAD_MUTEX_LOCK(mutex) do { \
82  int p_ret = starpu_pthread_mutex_lock(mutex); \
83  if (STARPU_UNLIKELY(p_ret)) { \
84  fprintf(stderr, \
85  "%s:%d starpu_pthread_mutex_lock: %s\n", \
86  __FILE__, __LINE__, strerror(p_ret)); \
87  STARPU_ABORT(); \
88  } \
89  _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__); \
90 } while (0)
91 
92 #define STARPU_PTHREAD_MUTEX_LOCK_SCHED(mutex) do { \
93  int p_ret = starpu_pthread_mutex_lock_sched(mutex); \
94  if (STARPU_UNLIKELY(p_ret)) { \
95  fprintf(stderr, \
96  "%s:%d starpu_pthread_mutex_lock_sched: %s\n", \
97  __FILE__, __LINE__, strerror(p_ret)); \
98  STARPU_ABORT(); \
99  } \
100 } while (0)
101 
102 #define STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) \
103  _starpu_pthread_mutex_trylock(mutex, __FILE__, __LINE__)
104 static STARPU_INLINE
105 int _starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex, char *file, int line)
106 {
107  int p_ret = starpu_pthread_mutex_trylock(mutex);
108  if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY)) {
109  fprintf(stderr,
110  "%s:%d starpu_pthread_mutex_trylock: %s\n",
111  file, line, strerror(p_ret));
112  STARPU_ABORT();
113  }
114  _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line);
115  return p_ret;
116 }
117 
118 #define STARPU_PTHREAD_MUTEX_TRYLOCK_SCHED(mutex) \
119  _starpu_pthread_mutex_trylock_sched(mutex, __FILE__, __LINE__)
120 static STARPU_INLINE
121 int _starpu_pthread_mutex_trylock_sched(starpu_pthread_mutex_t *mutex, char *file, int line)
122 {
123  int p_ret = starpu_pthread_mutex_trylock_sched(mutex);
124  if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY)) {
125  fprintf(stderr,
126  "%s:%d starpu_pthread_mutex_trylock_sched: %s\n",
127  file, line, strerror(p_ret));
128  STARPU_ABORT();
129  }
130  return p_ret;
131 }
132 
133 #define STARPU_PTHREAD_MUTEX_UNLOCK(mutex) do { \
134  _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__); \
135  int p_ret = starpu_pthread_mutex_unlock(mutex); \
136  if (STARPU_UNLIKELY(p_ret)) { \
137  fprintf(stderr, \
138  "%s:%d starpu_pthread_mutex_unlock: %s\n", \
139  __FILE__, __LINE__, strerror(p_ret)); \
140  STARPU_ABORT(); \
141  } \
142 } while (0)
143 
144 #define STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(mutex) do { \
145  int p_ret = starpu_pthread_mutex_unlock_sched(mutex); \
146  if (STARPU_UNLIKELY(p_ret)) { \
147  fprintf(stderr, \
148  "%s:%d starpu_pthread_mutex_unlock_sched: %s\n", \
149  __FILE__, __LINE__, strerror(p_ret)); \
150  STARPU_ABORT(); \
151  } \
152 } while (0)
153 
154 /*
155  * Encapsulation of the starpu_pthread_key_* functions.
156  */
157 #define STARPU_PTHREAD_KEY_CREATE(key, destr) do { \
158  int p_ret = starpu_pthread_key_create((key), (destr)); \
159  if (STARPU_UNLIKELY(p_ret != 0)) { \
160  fprintf(stderr, \
161  "%s:%d starpu_pthread_key_create: %s\n", \
162  __FILE__, __LINE__, strerror(p_ret)); \
163  } \
164 } while (0)
165 
166 #define STARPU_PTHREAD_KEY_DELETE(key) do { \
167  int p_ret = starpu_pthread_key_delete((key)); \
168  if (STARPU_UNLIKELY(p_ret != 0)) { \
169  fprintf(stderr, \
170  "%s:%d starpu_pthread_key_delete: %s\n", \
171  __FILE__, __LINE__, strerror(p_ret)); \
172  } \
173 } while (0)
174 
175 #define STARPU_PTHREAD_SETSPECIFIC(key, ptr) do { \
176  int p_ret = starpu_pthread_setspecific((key), (ptr)); \
177  if (STARPU_UNLIKELY(p_ret != 0)) { \
178  fprintf(stderr, \
179  "%s:%d starpu_pthread_setspecific: %s\n", \
180  __FILE__, __LINE__, strerror(p_ret)); \
181  }; \
182 } while (0)
183 
184 #define STARPU_PTHREAD_GETSPECIFIC(key) starpu_pthread_getspecific((key))
185 
186 /*
187  * Encapsulation of the starpu_pthread_rwlock_* functions.
188  */
189 #define STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) do { \
190  int p_ret = starpu_pthread_rwlock_init((rwlock), (attr)); \
191  if (STARPU_UNLIKELY(p_ret)) { \
192  fprintf(stderr, \
193  "%s:%d starpu_pthread_rwlock_init: %s\n", \
194  __FILE__, __LINE__, strerror(p_ret)); \
195  STARPU_ABORT(); \
196  } \
197 } while (0)
198 
199 #define STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) do { \
200  int p_ret = starpu_pthread_rwlock_rdlock(rwlock); \
201  if (STARPU_UNLIKELY(p_ret)) { \
202  fprintf(stderr, \
203  "%s:%d starpu_pthread_rwlock_rdlock: %s\n", \
204  __FILE__, __LINE__, strerror(p_ret)); \
205  STARPU_ABORT(); \
206  } \
207 } while (0)
208 
209 #define STARPU_PTHREAD_RWLOCK_TRYRDLOCK(rwlock) \
210  _starpu_pthread_rwlock_tryrdlock(rwlock, __FILE__, __LINE__)
211 static STARPU_INLINE
212 int _starpu_pthread_rwlock_tryrdlock(starpu_pthread_rwlock_t *rwlock, char *file, int line)
213 {
214  int p_ret = starpu_pthread_rwlock_tryrdlock(rwlock);
215  if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY)) {
216  fprintf(stderr,
217  "%s:%d starpu_pthread_rwlock_tryrdlock: %s\n",
218  file, line, strerror(p_ret));
219  STARPU_ABORT();
220  }
221  return p_ret;
222 }
223 
224 #define STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) do { \
225  int p_ret = starpu_pthread_rwlock_wrlock(rwlock); \
226  if (STARPU_UNLIKELY(p_ret)) { \
227  fprintf(stderr, \
228  "%s:%d starpu_pthread_rwlock_wrlock: %s\n", \
229  __FILE__, __LINE__, strerror(p_ret)); \
230  STARPU_ABORT(); \
231  } \
232 } while (0)
233 
234 #define STARPU_PTHREAD_RWLOCK_TRYWRLOCK(rwlock) \
235  _starpu_pthread_rwlock_trywrlock(rwlock, __FILE__, __LINE__)
236 static STARPU_INLINE
237 int _starpu_pthread_rwlock_trywrlock(starpu_pthread_rwlock_t *rwlock, char *file, int line)
238 {
239  int p_ret = starpu_pthread_rwlock_trywrlock(rwlock);
240  if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY)) {
241  fprintf(stderr,
242  "%s:%d starpu_pthread_rwlock_trywrlock: %s\n",
243  file, line, strerror(p_ret));
244  STARPU_ABORT();
245  }
246  return p_ret;
247 }
248 
249 #define STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) do { \
250  int p_ret = starpu_pthread_rwlock_unlock(rwlock); \
251  if (STARPU_UNLIKELY(p_ret)) { \
252  fprintf(stderr, \
253  "%s:%d starpu_pthread_rwlock_unlock: %s\n", \
254  __FILE__, __LINE__, strerror(p_ret)); \
255  STARPU_ABORT(); \
256  } \
257 } while (0)
258 
259 #define STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) do { \
260  int p_ret = starpu_pthread_rwlock_destroy(rwlock); \
261  if (STARPU_UNLIKELY(p_ret)) { \
262  fprintf(stderr, \
263  "%s:%d starpu_pthread_rwlock_destroy: %s\n", \
264  __FILE__, __LINE__, strerror(p_ret)); \
265  STARPU_ABORT(); \
266  } \
267 } while (0)
268 
269 /*
270  * Encapsulation of the starpu_pthread_cond_* functions.
271  */
272 #define STARPU_PTHREAD_COND_INIT(cond, attr) do { \
273  int p_ret = starpu_pthread_cond_init((cond), (attr)); \
274  if (STARPU_UNLIKELY(p_ret)) { \
275  fprintf(stderr, \
276  "%s:%d starpu_pthread_cond_init: %s\n", \
277  __FILE__, __LINE__, strerror(p_ret)); \
278  STARPU_ABORT(); \
279  } \
280 } while (0)
281 
282 #define STARPU_PTHREAD_COND_DESTROY(cond) do { \
283  int p_ret = starpu_pthread_cond_destroy(cond); \
284  if (STARPU_UNLIKELY(p_ret)) { \
285  fprintf(stderr, \
286  "%s:%d starpu_pthread_cond_destroy: %s\n", \
287  __FILE__, __LINE__, strerror(p_ret)); \
288  STARPU_ABORT(); \
289  } \
290 } while (0)
291 
292 #define STARPU_PTHREAD_COND_SIGNAL(cond) do { \
293  int p_ret = starpu_pthread_cond_signal(cond); \
294  if (STARPU_UNLIKELY(p_ret)) { \
295  fprintf(stderr, \
296  "%s:%d starpu_pthread_cond_signal: %s\n", \
297  __FILE__, __LINE__, strerror(p_ret)); \
298  STARPU_ABORT(); \
299  } \
300 } while (0)
301 
302 #define STARPU_PTHREAD_COND_BROADCAST(cond) do { \
303  int p_ret = starpu_pthread_cond_broadcast(cond); \
304  if (STARPU_UNLIKELY(p_ret)) { \
305  fprintf(stderr, \
306  "%s:%d starpu_pthread_cond_broadcast: %s\n", \
307  __FILE__, __LINE__, strerror(p_ret)); \
308  STARPU_ABORT(); \
309  } \
310 } while (0)
311 
312 #define STARPU_PTHREAD_COND_WAIT(cond, mutex) do { \
313  int p_ret = starpu_pthread_cond_wait((cond), (mutex)); \
314  if (STARPU_UNLIKELY(p_ret)) { \
315  fprintf(stderr, \
316  "%s:%d starpu_pthread_cond_wait: %s\n", \
317  __FILE__, __LINE__, strerror(p_ret)); \
318  STARPU_ABORT(); \
319  } \
320 } while (0)
321 
322 /*
323  * Encapsulation of the starpu_pthread_barrier_* functions.
324  */
325 
326 #define STARPU_PTHREAD_BARRIER_INIT(barrier, attr, count) do { \
327  int p_ret = starpu_pthread_barrier_init((barrier), (attr), (count)); \
328  if (STARPU_UNLIKELY(p_ret)) { \
329  fprintf(stderr, \
330  "%s:%d starpu_pthread_barrier_init: %s\n", \
331  __FILE__, __LINE__, strerror(p_ret)); \
332  STARPU_ABORT(); \
333  } \
334 } while (0)
335 
336 #define STARPU_PTHREAD_BARRIER_DESTROY(barrier) do { \
337  int p_ret = starpu_pthread_barrier_destroy((barrier)); \
338  if (STARPU_UNLIKELY(p_ret)) { \
339  fprintf(stderr, \
340  "%s:%d starpu_pthread_barrier_destroy: %s\n", \
341  __FILE__, __LINE__, strerror(p_ret)); \
342  STARPU_ABORT(); \
343  } \
344 } while (0)
345 
346 #define STARPU_PTHREAD_BARRIER_WAIT(barrier) do { \
347  int p_ret = starpu_pthread_barrier_wait((barrier)); \
348  if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == STARPU_PTHREAD_BARRIER_SERIAL_THREAD)))) { \
349  fprintf(stderr, \
350  "%s:%d starpu_pthread_barrier_wait: %s\n", \
351  __FILE__, __LINE__, strerror(p_ret)); \
352  STARPU_ABORT(); \
353  } \
354 } while (0)
355 #endif /* _MSC_VER */
356 
357 #endif /* __STARPU_THREAD_UTIL_H__ */
#define STARPU_UNLIKELY(expr)
Definition: starpu_util.h:57
int starpu_pthread_rwlock_trywrlock(starpu_pthread_rwlock_t *rwlock)
int starpu_pthread_rwlock_tryrdlock(starpu_pthread_rwlock_t *rwlock)
#define STARPU_ABORT()
Definition: starpu_util.h:139
int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex)