StarPU Handbook
Loading...
Searching...
No Matches
starpu_thread_util.h
Go to the documentation of this file.
1/* StarPU --- Runtime system for heterogeneous multicore architectures.
2 *
3 * Copyright (C) 2010-2024 Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
4 *
5 * StarPU is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License as published by
7 * the Free Software Foundation; either version 2.1 of the License, or (at
8 * your option) any later version.
9 *
10 * StarPU is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 *
14 * See the GNU Lesser General Public License in COPYING.LGPL for more details.
15 */
16
17// The documentation for this file is in doc/doxygen/chapters/api/threads.doxy
18
19#ifndef __STARPU_THREAD_UTIL_H__
20#define __STARPU_THREAD_UTIL_H__
21
22#include <starpu_util.h>
23#include <starpu_thread.h>
24#include <errno.h>
25
26#ifdef __cplusplus
27extern "C" {
28#endif
29
30#if !(defined(_MSC_VER) && !defined(BUILDING_STARPU))
31/*
32 * Encapsulation of the starpu_pthread_create_* functions.
33 */
34
35#define STARPU_PTHREAD_CREATE_ON(name, thread, attr, routine, arg, where) \
36 do { \
37 int p_ret = starpu_pthread_create_on((name), (thread), (attr), (routine), (arg), (where)); \
38 if (STARPU_UNLIKELY(p_ret != 0)) \
39 { \
40 fprintf(stderr, \
41 "%s:%d starpu_pthread_create_on: %s\n", \
42 __FILE__, __LINE__, strerror(p_ret)); \
43 STARPU_ABORT(); \
44 } \
45 } \
46 while (0)
47
48#define STARPU_PTHREAD_CREATE(thread, attr, routine, arg) \
49 do { \
50 int p_ret = starpu_pthread_create((thread), (attr), (routine), (arg)); \
51 if (STARPU_UNLIKELY(p_ret != 0)) \
52 { \
53 fprintf(stderr, \
54 "%s:%d starpu_pthread_create: %s\n", \
55 __FILE__, __LINE__, strerror(p_ret)); \
56 STARPU_ABORT(); \
57 } \
58 } \
59 while (0)
60
61#define STARPU_PTHREAD_JOIN(thread, retval) \
62 do { \
63 int p_ret = starpu_pthread_join((thread), (retval)); \
64 if (STARPU_UNLIKELY(p_ret != 0)) \
65 { \
66 fprintf(stderr, \
67 "%s:%d starpu_pthread_join: %s\n", \
68 __FILE__, __LINE__, strerror(p_ret)); \
69 STARPU_ABORT(); \
70 } \
71 } \
72 while (0)
73
74/*
75 * Encapsulation of the starpu_pthread_mutex_* functions.
76 */
77
78#define _STARPU_PTHREAD_MUTEX_INIT(mutex, attr) \
79 do { \
80 int p_ret = starpu_pthread_mutex_init((mutex), (attr)); \
81 if (STARPU_UNLIKELY(p_ret)) \
82 { \
83 fprintf(stderr, \
84 "%s:%d starpu_pthread_mutex_init: %s\n", \
85 __FILE__, __LINE__, strerror(p_ret)); \
86 STARPU_ABORT(); \
87 } \
88 } \
89 while (0)
90
91#ifdef STARPU_PTHREAD_MUTEX_INITIALIZER_ZERO
92#define STARPU_PTHREAD_MUTEX_INIT(mutex, attr) \
93 do { \
94 if (!attr) \
95 memset(mutex, 0, sizeof(*mutex)); \
96 else \
97 _STARPU_PTHREAD_MUTEX_INIT(mutex, attr); \
98 } \
99 while (0)
100#define STARPU_PTHREAD_MUTEX_INIT0(mutex, attr) \
101 do { \
102 if (attr) \
103 _STARPU_PTHREAD_MUTEX_INIT(mutex, attr); \
104 } \
105 while (0)
106#else
107#define STARPU_PTHREAD_MUTEX_INIT(mutex, attr) _STARPU_PTHREAD_MUTEX_INIT(mutex, attr)
108#define STARPU_PTHREAD_MUTEX_INIT0(mutex, attr) _STARPU_PTHREAD_MUTEX_INIT(mutex, attr)
109#endif
110
111#define STARPU_PTHREAD_MUTEX_DESTROY(mutex) \
112 do { \
113 int p_ret = starpu_pthread_mutex_destroy(mutex); \
114 if (STARPU_UNLIKELY(p_ret)) \
115 { \
116 fprintf(stderr, \
117 "%s:%d starpu_pthread_mutex_destroy: %s\n", \
118 __FILE__, __LINE__, strerror(p_ret)); \
119 STARPU_ABORT(); \
120 } \
121 } \
122 while (0)
123
124#ifdef STARPU_DEBUG
125#define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line) \
126 starpu_pthread_mutex_check_sched((mutex), file, line)
127#else
128#define _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line)
129#endif
130
131#define STARPU_PTHREAD_MUTEX_LOCK(mutex) \
132 do { \
133 int p_ret = starpu_pthread_mutex_lock(mutex); \
134 if (STARPU_UNLIKELY(p_ret)) \
135 { \
136 fprintf(stderr, \
137 "%s:%d starpu_pthread_mutex_lock: %s\n", \
138 __FILE__, __LINE__, strerror(p_ret)); \
139 STARPU_ABORT(); \
140 } \
141 _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__); \
142 } \
143 while (0)
144
145#define STARPU_PTHREAD_MUTEX_LOCK_SCHED(mutex) \
146 do { \
147 int p_ret = starpu_pthread_mutex_lock_sched(mutex); \
148 if (STARPU_UNLIKELY(p_ret)) \
149 { \
150 fprintf(stderr, \
151 "%s:%d starpu_pthread_mutex_lock_sched: %s\n", \
152 __FILE__, __LINE__, strerror(p_ret)); \
153 STARPU_ABORT(); \
154 } \
155 } \
156 while (0)
157
158#define STARPU_PTHREAD_MUTEX_TRYLOCK(mutex) \
159 _starpu_pthread_mutex_trylock(mutex, __FILE__, __LINE__)
160static STARPU_INLINE int _starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex, char *file, int line)
161{
162 int p_ret = starpu_pthread_mutex_trylock(mutex);
163 if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY))
164 {
165 fprintf(stderr,
166 "%s:%d starpu_pthread_mutex_trylock: %s\n",
167 file, line, strerror(p_ret));
168 STARPU_ABORT();
169 }
170 _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, file, line);
171 return p_ret;
172}
173
174#define STARPU_PTHREAD_MUTEX_TRYLOCK_SCHED(mutex) \
175 _starpu_pthread_mutex_trylock_sched(mutex, __FILE__, __LINE__)
176static STARPU_INLINE int _starpu_pthread_mutex_trylock_sched(starpu_pthread_mutex_t *mutex, char *file, int line)
177{
178 int p_ret = starpu_pthread_mutex_trylock_sched(mutex);
179 if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY))
180 {
181 fprintf(stderr,
182 "%s:%d starpu_pthread_mutex_trylock_sched: %s\n",
183 file, line, strerror(p_ret));
184 STARPU_ABORT();
185 }
186 return p_ret;
187}
188
189#define STARPU_PTHREAD_MUTEX_UNLOCK(mutex) \
190 do { \
191 _STARPU_CHECK_NOT_SCHED_MUTEX(mutex, __FILE__, __LINE__); \
192 int p_ret = starpu_pthread_mutex_unlock(mutex); \
193 if (STARPU_UNLIKELY(p_ret)) \
194 { \
195 fprintf(stderr, \
196 "%s:%d starpu_pthread_mutex_unlock: %s\n", \
197 __FILE__, __LINE__, strerror(p_ret)); \
198 STARPU_ABORT(); \
199 } \
200 } \
201 while (0)
202
203#define STARPU_PTHREAD_MUTEX_UNLOCK_SCHED(mutex) \
204 do { \
205 int p_ret = starpu_pthread_mutex_unlock_sched(mutex); \
206 if (STARPU_UNLIKELY(p_ret)) \
207 { \
208 fprintf(stderr, \
209 "%s:%d starpu_pthread_mutex_unlock_sched: %s\n", \
210 __FILE__, __LINE__, strerror(p_ret)); \
211 STARPU_ABORT(); \
212 } \
213 } \
214 while (0)
215
216/*
217 * Encapsulation of the starpu_pthread_key_* functions.
218 */
219#define STARPU_PTHREAD_KEY_CREATE(key, destr) \
220 do { \
221 int p_ret = starpu_pthread_key_create((key), (destr)); \
222 if (STARPU_UNLIKELY(p_ret != 0)) \
223 { \
224 fprintf(stderr, \
225 "%s:%d starpu_pthread_key_create: %s\n", \
226 __FILE__, __LINE__, strerror(p_ret)); \
227 } \
228 } \
229 while (0)
230
231#define STARPU_PTHREAD_KEY_DELETE(key) \
232 do { \
233 int p_ret = starpu_pthread_key_delete((key)); \
234 if (STARPU_UNLIKELY(p_ret != 0)) \
235 { \
236 fprintf(stderr, \
237 "%s:%d starpu_pthread_key_delete: %s\n", \
238 __FILE__, __LINE__, strerror(p_ret)); \
239 } \
240 } \
241 while (0)
242
243#define STARPU_PTHREAD_SETSPECIFIC(key, ptr) \
244 do { \
245 int p_ret = starpu_pthread_setspecific((key), (ptr)); \
246 if (STARPU_UNLIKELY(p_ret != 0)) \
247 { \
248 fprintf(stderr, \
249 "%s:%d starpu_pthread_setspecific: %s\n", \
250 __FILE__, __LINE__, strerror(p_ret)); \
251 }; \
252 } \
253 while (0)
254
255#define STARPU_PTHREAD_GETSPECIFIC(key) starpu_pthread_getspecific((key))
256
257/*
258 * Encapsulation of the starpu_pthread_rwlock_* functions.
259 */
260#define _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) \
261 do { \
262 int p_ret = starpu_pthread_rwlock_init((rwlock), (attr)); \
263 if (STARPU_UNLIKELY(p_ret)) \
264 { \
265 fprintf(stderr, \
266 "%s:%d starpu_pthread_rwlock_init: %s\n", \
267 __FILE__, __LINE__, strerror(p_ret)); \
268 STARPU_ABORT(); \
269 } \
270 } \
271 while (0)
272
273#ifdef STARPU_PTHREAD_RWLOCK_INITIALIZER_ZERO
274#define STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) \
275 do { \
276 if (!attr) \
277 memset(rwlock, 0, sizeof(*rwlock)); \
278 else \
279 _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr); \
280 } \
281 while (0)
282#define STARPU_PTHREAD_RWLOCK_INIT0(rwlock, attr) \
283 do { \
284 if (attr) \
285 _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr); \
286 } \
287 while (0)
288#else
289#define STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr) _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr)
290#define STARPU_PTHREAD_RWLOCK_INIT0(rwlock, attr) _STARPU_PTHREAD_RWLOCK_INIT(rwlock, attr)
291#endif
292
293#define STARPU_PTHREAD_RWLOCK_RDLOCK(rwlock) \
294 do { \
295 int p_ret = starpu_pthread_rwlock_rdlock(rwlock); \
296 if (STARPU_UNLIKELY(p_ret)) \
297 { \
298 fprintf(stderr, \
299 "%s:%d starpu_pthread_rwlock_rdlock: %s\n", \
300 __FILE__, __LINE__, strerror(p_ret)); \
301 STARPU_ABORT(); \
302 } \
303 } \
304 while (0)
305
306#define STARPU_PTHREAD_RWLOCK_TRYRDLOCK(rwlock) \
307 _starpu_pthread_rwlock_tryrdlock(rwlock, __FILE__, __LINE__)
308static STARPU_INLINE int _starpu_pthread_rwlock_tryrdlock(starpu_pthread_rwlock_t *rwlock, char *file, int line)
309{
310 int p_ret = starpu_pthread_rwlock_tryrdlock(rwlock);
311 if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY))
312 {
313 fprintf(stderr,
314 "%s:%d starpu_pthread_rwlock_tryrdlock: %s\n",
315 file, line, strerror(p_ret));
316 STARPU_ABORT();
317 }
318 return p_ret;
319}
320
321#define STARPU_PTHREAD_RWLOCK_WRLOCK(rwlock) \
322 do { \
323 int p_ret = starpu_pthread_rwlock_wrlock(rwlock); \
324 if (STARPU_UNLIKELY(p_ret)) \
325 { \
326 fprintf(stderr, \
327 "%s:%d starpu_pthread_rwlock_wrlock: %s\n", \
328 __FILE__, __LINE__, strerror(p_ret)); \
329 STARPU_ABORT(); \
330 } \
331 } \
332 while (0)
333
334#define STARPU_PTHREAD_RWLOCK_TRYWRLOCK(rwlock) \
335 _starpu_pthread_rwlock_trywrlock(rwlock, __FILE__, __LINE__)
336static STARPU_INLINE int _starpu_pthread_rwlock_trywrlock(starpu_pthread_rwlock_t *rwlock, char *file, int line)
337{
338 int p_ret = starpu_pthread_rwlock_trywrlock(rwlock);
339 if (STARPU_UNLIKELY(p_ret != 0 && p_ret != EBUSY))
340 {
341 fprintf(stderr,
342 "%s:%d starpu_pthread_rwlock_trywrlock: %s\n",
343 file, line, strerror(p_ret));
344 STARPU_ABORT();
345 }
346 return p_ret;
347}
348
349#define STARPU_PTHREAD_RWLOCK_UNLOCK(rwlock) \
350 do { \
351 int p_ret = starpu_pthread_rwlock_unlock(rwlock); \
352 if (STARPU_UNLIKELY(p_ret)) \
353 { \
354 fprintf(stderr, \
355 "%s:%d starpu_pthread_rwlock_unlock: %s\n", \
356 __FILE__, __LINE__, strerror(p_ret)); \
357 STARPU_ABORT(); \
358 } \
359 } \
360 while (0)
361
362#define STARPU_PTHREAD_RWLOCK_DESTROY(rwlock) \
363 do { \
364 int p_ret = starpu_pthread_rwlock_destroy(rwlock); \
365 if (STARPU_UNLIKELY(p_ret)) \
366 { \
367 fprintf(stderr, \
368 "%s:%d starpu_pthread_rwlock_destroy: %s\n", \
369 __FILE__, __LINE__, strerror(p_ret)); \
370 STARPU_ABORT(); \
371 } \
372 } \
373 while (0)
374
375/*
376 * Encapsulation of the starpu_pthread_cond_* functions.
377 */
378#define _STARPU_PTHREAD_COND_INIT(cond, attr) \
379 do { \
380 int p_ret = starpu_pthread_cond_init((cond), (attr)); \
381 if (STARPU_UNLIKELY(p_ret)) \
382 { \
383 fprintf(stderr, \
384 "%s:%d starpu_pthread_cond_init: %s\n", \
385 __FILE__, __LINE__, strerror(p_ret)); \
386 STARPU_ABORT(); \
387 } \
388 } \
389 while (0)
390
391#ifdef STARPU_PTHREAD_COND_INITIALIZER_ZERO
392#define STARPU_PTHREAD_COND_INIT(cond, attr) \
393 do { \
394 if (!attr) \
395 memset(cond, 0, sizeof(*cond)); \
396 else \
397 _STARPU_PTHREAD_COND_INIT(cond, attr); \
398 } \
399 while (0)
400#define STARPU_PTHREAD_COND_INIT0(cond, attr) \
401 do { \
402 if (attr) \
403 _STARPU_PTHREAD_COND_INIT(cond, attr); \
404 } \
405 while (0)
406#else
407#define STARPU_PTHREAD_COND_INIT(cond, attr) _STARPU_PTHREAD_COND_INIT(cond, attr)
408#define STARPU_PTHREAD_COND_INIT0(cond, attr) _STARPU_PTHREAD_COND_INIT(cond, attr)
409#endif
410
411#define STARPU_PTHREAD_COND_DESTROY(cond) \
412 do { \
413 int p_ret = starpu_pthread_cond_destroy(cond); \
414 if (STARPU_UNLIKELY(p_ret)) \
415 { \
416 fprintf(stderr, \
417 "%s:%d starpu_pthread_cond_destroy: %s\n", \
418 __FILE__, __LINE__, strerror(p_ret)); \
419 STARPU_ABORT(); \
420 } \
421 } \
422 while (0)
423
424#define STARPU_PTHREAD_COND_SIGNAL(cond) \
425 do { \
426 int p_ret = starpu_pthread_cond_signal(cond); \
427 if (STARPU_UNLIKELY(p_ret)) \
428 { \
429 fprintf(stderr, \
430 "%s:%d starpu_pthread_cond_signal: %s\n", \
431 __FILE__, __LINE__, strerror(p_ret)); \
432 STARPU_ABORT(); \
433 } \
434 } \
435 while (0)
436
437#define STARPU_PTHREAD_COND_BROADCAST(cond) \
438 do { \
439 int p_ret = starpu_pthread_cond_broadcast(cond); \
440 if (STARPU_UNLIKELY(p_ret)) \
441 { \
442 fprintf(stderr, \
443 "%s:%d starpu_pthread_cond_broadcast: %s\n", \
444 __FILE__, __LINE__, strerror(p_ret)); \
445 STARPU_ABORT(); \
446 } \
447 } \
448 while (0)
449
450#define STARPU_PTHREAD_COND_WAIT(cond, mutex) \
451 do { \
452 int p_ret = starpu_pthread_cond_wait((cond), (mutex)); \
453 if (STARPU_UNLIKELY(p_ret)) \
454 { \
455 fprintf(stderr, \
456 "%s:%d starpu_pthread_cond_wait: %s\n", \
457 __FILE__, __LINE__, strerror(p_ret)); \
458 STARPU_ABORT(); \
459 } \
460 } \
461 while (0)
462
463/* pthread_cond_timedwait not yet available on windows, but we don't run simgrid there anyway */
464#ifdef STARPU_SIMGRID
465#define STARPU_PTHREAD_COND_TIMEDWAIT(cond, mutex, abstime) \
466 _starpu_pthread_cond_timedwait(cond, mutex, abstime, __FILE__, __LINE__)
467static STARPU_INLINE int _starpu_pthread_cond_timedwait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex, const struct timespec *abstime, char *file, int line)
468{
469 int p_ret = starpu_pthread_cond_timedwait(cond, mutex, abstime);
470 if (STARPU_UNLIKELY(p_ret != 0 && p_ret != ETIMEDOUT))
471 {
472 fprintf(stderr,
473 "%s:%d starpu_pthread_cond_timedwait: %s\n",
474 file, line, strerror(p_ret));
475 STARPU_ABORT();
476 }
477 return p_ret;
478}
479#endif
480
481/*
482 * Encapsulation of the starpu_pthread_barrier_* functions.
483 */
484
485#define STARPU_PTHREAD_BARRIER_INIT(barrier, attr, count) \
486 do { \
487 int p_ret = starpu_pthread_barrier_init((barrier), (attr), (count)); \
488 if (STARPU_UNLIKELY(p_ret)) \
489 { \
490 fprintf(stderr, \
491 "%s:%d starpu_pthread_barrier_init: %s\n", \
492 __FILE__, __LINE__, strerror(p_ret)); \
493 STARPU_ABORT(); \
494 } \
495 } \
496 while (0)
497
498#define STARPU_PTHREAD_BARRIER_DESTROY(barrier) \
499 do { \
500 int p_ret = starpu_pthread_barrier_destroy((barrier)); \
501 if (STARPU_UNLIKELY(p_ret)) \
502 { \
503 fprintf(stderr, \
504 "%s:%d starpu_pthread_barrier_destroy: %s\n", \
505 __FILE__, __LINE__, strerror(p_ret)); \
506 STARPU_ABORT(); \
507 } \
508 } \
509 while (0)
510
511#define STARPU_PTHREAD_BARRIER_WAIT(barrier) \
512 do { \
513 int p_ret = starpu_pthread_barrier_wait((barrier)); \
514 if (STARPU_UNLIKELY(!((p_ret == 0) || (p_ret == STARPU_PTHREAD_BARRIER_SERIAL_THREAD)))) \
515 { \
516 fprintf(stderr, \
517 "%s:%d starpu_pthread_barrier_wait: %s\n", \
518 __FILE__, __LINE__, strerror(p_ret)); \
519 STARPU_ABORT(); \
520 } \
521 } \
522 while (0)
523#endif /* _MSC_VER */
524
525#ifdef __cplusplus
526}
527#endif
528
529#endif /* __STARPU_THREAD_UTIL_H__ */
#define STARPU_UNLIKELY(expr)
Definition starpu_util.h:65
#define STARPU_ABORT()
Definition starpu_util.h:342