ARGOBOTS  c6511494322293e01714f56f341b8d2b22c1e3c1
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
abti_error.h
Go to the documentation of this file.
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 /*
3  * See COPYRIGHT in top-level directory.
4  */
5 
6 #ifndef ABTI_ERROR_H_INCLUDED
7 #define ABTI_ERROR_H_INCLUDED
8 
9 #include <assert.h>
10 #include <abt_config.h>
11 
12 #define ABTI_ASSERT(cond) \
13  do { \
14  if (ABTI_IS_ERROR_CHECK_ENABLED) { \
15  assert(cond); \
16  } \
17  } while (0)
18 
19 #define ABTI_STATIC_ASSERT(cond) \
20  do { \
21  ((void)sizeof(char[2 * !!(cond)-1])); \
22  } while (0)
23 
24 #ifdef ABT_CONFIG_PRINT_ABT_ERRNO
25 #define ABTI_IS_PRINT_ABT_ERRNO_ENABLED 1
26 #else
27 #define ABTI_IS_PRINT_ABT_ERRNO_ENABLED 0
28 #endif
29 
30 #define HANDLE_WARNING(msg) \
31  do { \
32  if (ABTI_IS_PRINT_ABT_ERRNO_ENABLED) { \
33  fprintf(stderr, "[%s:%d] %s\n", __FILE__, __LINE__, msg); \
34  } \
35  } while (0)
36 
37 #define HANDLE_ERROR(msg) \
38  do { \
39  if (ABTI_IS_PRINT_ABT_ERRNO_ENABLED) { \
40  fprintf(stderr, "[%s:%d] %s\n", __FILE__, __LINE__, msg); \
41  } \
42  } while (0)
43 
44 #define HANDLE_ERROR_WITH_CODE(msg, n) \
45  do { \
46  if (ABTI_IS_PRINT_ABT_ERRNO_ENABLED) { \
47  fprintf(stderr, "[%s:%d] %s: %d\n", __FILE__, __LINE__, msg, n); \
48  } \
49  } while (0)
50 
51 #define HANDLE_ERROR_FUNC_WITH_CODE(n) \
52  do { \
53  if (ABTI_IS_PRINT_ABT_ERRNO_ENABLED) { \
54  fprintf(stderr, "[%s:%d] %s: %d\n", __FILE__, __LINE__, __func__, \
55  n); \
56  } \
57  } while (0)
58 
59 #define ABTI_SETUP_WITH_INIT_CHECK() \
60  do { \
61  if (ABTI_IS_ERROR_CHECK_ENABLED && \
62  ABTU_unlikely(gp_ABTI_global == NULL)) { \
63  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_UNINITIALIZED); \
64  return ABT_ERR_UNINITIALIZED; \
65  } \
66  } while (0)
67 
68 #define ABTI_SETUP_LOCAL_XSTREAM(pp_local_xstream) \
69  do { \
70  ABTI_xstream *p_local_xstream_tmp = \
71  ABTI_local_get_xstream_or_null(ABTI_local_get_local()); \
72  if (ABTI_IS_EXT_THREAD_ENABLED && \
73  ABTU_unlikely(p_local_xstream_tmp == NULL)) { \
74  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_XSTREAM); \
75  return ABT_ERR_INV_XSTREAM; \
76  } \
77  ABTI_xstream **pp_local_xstream_tmp = (pp_local_xstream); \
78  if (pp_local_xstream_tmp) { \
79  *pp_local_xstream_tmp = p_local_xstream_tmp; \
80  } \
81  } while (0)
82 
83 #define ABTI_SETUP_LOCAL_YTHREAD(pp_local_xstream, pp_ythread) \
84  do { \
85  ABTI_xstream *p_local_xstream_tmp = \
86  ABTI_local_get_xstream_or_null(ABTI_local_get_local()); \
87  if (ABTI_IS_ERROR_CHECK_ENABLED && ABTI_IS_EXT_THREAD_ENABLED && \
88  ABTU_unlikely(p_local_xstream_tmp == NULL)) { \
89  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_XSTREAM); \
90  return ABT_ERR_INV_XSTREAM; \
91  } \
92  ABTI_xstream **pp_local_xstream_tmp = (pp_local_xstream); \
93  if (pp_local_xstream_tmp) { \
94  *pp_local_xstream_tmp = p_local_xstream_tmp; \
95  } \
96  ABTI_thread *p_thread_tmp = p_local_xstream_tmp->p_thread; \
97  if (ABTI_IS_ERROR_CHECK_ENABLED && \
98  ABTU_unlikely( \
99  !(p_thread_tmp->type & ABTI_THREAD_TYPE_YIELDABLE))) { \
100  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_THREAD); \
101  return ABT_ERR_INV_THREAD; \
102  } \
103  ABTI_ythread **pp_ythread_tmp = (pp_ythread); \
104  if (pp_ythread_tmp) { \
105  *pp_ythread_tmp = ABTI_thread_get_ythread(p_thread_tmp); \
106  } \
107  } while (0)
108 
109 #define ABTI_SETUP_LOCAL_XSTREAM_WITH_INIT_CHECK(pp_local_xstream) \
110  do { \
111  ABTI_SETUP_WITH_INIT_CHECK(); \
112  ABTI_SETUP_LOCAL_XSTREAM(pp_local_xstream); \
113  } while (0)
114 
115 #define ABTI_SETUP_LOCAL_YTHREAD_WITH_INIT_CHECK(pp_local_xstream, pp_ythread) \
116  do { \
117  ABTI_SETUP_WITH_INIT_CHECK(); \
118  ABTI_SETUP_LOCAL_YTHREAD(pp_local_xstream, pp_ythread); \
119  } while (0)
120 
121 #define ABTI_HANDLE_ERROR(n) \
122  do { \
123  HANDLE_ERROR_FUNC_WITH_CODE(n); \
124  return n; \
125  } while (0)
126 
127 #define ABTI_CHECK_ERROR(abt_errno) \
128  do { \
129  int abt_errno_ = (abt_errno); \
130  if (ABTI_IS_ERROR_CHECK_ENABLED && \
131  ABTU_unlikely(abt_errno_ != ABT_SUCCESS)) { \
132  HANDLE_ERROR_FUNC_WITH_CODE(abt_errno_); \
133  return abt_errno_; \
134  } \
135  } while (0)
136 
137 #define ABTI_CHECK_TRUE(cond, abt_errno) \
138  do { \
139  if (ABTI_IS_ERROR_CHECK_ENABLED && ABTU_unlikely(!(cond))) { \
140  int abt_errno_ = (abt_errno); \
141  HANDLE_ERROR_FUNC_WITH_CODE(abt_errno_); \
142  return abt_errno_; \
143  } \
144  } while (0)
145 
146 #define ABTI_CHECK_YIELDABLE(p_thread, pp_ythread, abt_errno) \
147  do { \
148  ABTI_thread *p_tmp = (p_thread); \
149  if (ABTI_IS_ERROR_CHECK_ENABLED && \
150  ABTU_unlikely(!(p_tmp->type & ABTI_THREAD_TYPE_YIELDABLE))) { \
151  int abt_errno_ = (abt_errno); \
152  HANDLE_ERROR_FUNC_WITH_CODE(abt_errno_); \
153  return abt_errno_; \
154  } \
155  *(pp_ythread) = ABTI_thread_get_ythread(p_tmp); \
156  } while (0)
157 
158 #define ABTI_CHECK_TRUE_MSG(cond, abt_errno, msg) \
159  do { \
160  if (ABTI_IS_ERROR_CHECK_ENABLED && ABTU_unlikely(!(cond))) { \
161  HANDLE_ERROR(msg); \
162  return (abt_errno); \
163  } \
164  } while (0)
165 
166 #define ABTI_CHECK_NULL_XSTREAM_PTR(p) \
167  do { \
168  if (ABTI_IS_ERROR_CHECK_ENABLED && \
169  ABTU_unlikely(p == (ABTI_xstream *)NULL)) { \
170  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_XSTREAM); \
171  return ABT_ERR_INV_XSTREAM; \
172  } \
173  } while (0)
174 
175 #define ABTI_CHECK_NULL_POOL_PTR(p) \
176  do { \
177  if (ABTI_IS_ERROR_CHECK_ENABLED && \
178  ABTU_unlikely(p == (ABTI_pool *)NULL)) { \
179  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_POOL); \
180  return ABT_ERR_INV_POOL; \
181  } \
182  } while (0)
183 
184 #define ABTI_CHECK_NULL_SCHED_PTR(p) \
185  do { \
186  if (ABTI_IS_ERROR_CHECK_ENABLED && \
187  ABTU_unlikely(p == (ABTI_sched *)NULL)) { \
188  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_SCHED); \
189  return ABT_ERR_INV_SCHED; \
190  } \
191  } while (0)
192 
193 #define ABTI_CHECK_NULL_THREAD_PTR(p) \
194  do { \
195  if (ABTI_IS_ERROR_CHECK_ENABLED && \
196  ABTU_unlikely(p == (ABTI_thread *)NULL)) { \
197  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_THREAD); \
198  return ABT_ERR_INV_THREAD; \
199  } \
200  } while (0)
201 
202 #define ABTI_CHECK_NULL_YTHREAD_PTR(p) \
203  do { \
204  if (ABTI_IS_ERROR_CHECK_ENABLED && \
205  ABTU_unlikely(p == (ABTI_ythread *)NULL)) { \
206  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_THREAD); \
207  return ABT_ERR_INV_THREAD; \
208  } \
209  } while (0)
210 
211 #define ABTI_CHECK_NULL_THREAD_ATTR_PTR(p) \
212  do { \
213  if (ABTI_IS_ERROR_CHECK_ENABLED && \
214  ABTU_unlikely(p == (ABTI_thread_attr *)NULL)) { \
215  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_THREAD_ATTR); \
216  return ABT_ERR_INV_THREAD_ATTR; \
217  } \
218  } while (0)
219 
220 #define ABTI_CHECK_NULL_TASK_PTR(p) \
221  do { \
222  if (ABTI_IS_ERROR_CHECK_ENABLED && \
223  ABTU_unlikely(p == (ABTI_thread *)NULL)) { \
224  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_TASK); \
225  return ABT_ERR_INV_TASK; \
226  } \
227  } while (0)
228 
229 #define ABTI_CHECK_NULL_KEY_PTR(p) \
230  do { \
231  if (ABTI_IS_ERROR_CHECK_ENABLED && \
232  ABTU_unlikely(p == (ABTI_key *)NULL)) { \
233  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_KEY); \
234  return ABT_ERR_INV_KEY; \
235  } \
236  } while (0)
237 
238 #define ABTI_CHECK_NULL_MUTEX_PTR(p) \
239  do { \
240  if (ABTI_IS_ERROR_CHECK_ENABLED && \
241  ABTU_unlikely(p == (ABTI_mutex *)NULL)) { \
242  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_MUTEX); \
243  return ABT_ERR_INV_MUTEX; \
244  } \
245  } while (0)
246 
247 #define ABTI_CHECK_NULL_MUTEX_ATTR_PTR(p) \
248  do { \
249  if (ABTI_IS_ERROR_CHECK_ENABLED && \
250  ABTU_unlikely(p == (ABTI_mutex_attr *)NULL)) { \
251  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_MUTEX_ATTR); \
252  return ABT_ERR_INV_MUTEX_ATTR; \
253  } \
254  } while (0)
255 
256 #define ABTI_CHECK_NULL_COND_PTR(p) \
257  do { \
258  if (ABTI_IS_ERROR_CHECK_ENABLED && \
259  ABTU_unlikely(p == (ABTI_cond *)NULL)) { \
260  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_COND); \
261  return ABT_ERR_INV_COND; \
262  } \
263  } while (0)
264 
265 #define ABTI_CHECK_NULL_RWLOCK_PTR(p) \
266  do { \
267  if (ABTI_IS_ERROR_CHECK_ENABLED && \
268  ABTU_unlikely(p == (ABTI_rwlock *)NULL)) { \
269  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_RWLOCK); \
270  return ABT_ERR_INV_RWLOCK; \
271  } \
272  } while (0)
273 
274 #define ABTI_CHECK_NULL_FUTURE_PTR(p) \
275  do { \
276  if (ABTI_IS_ERROR_CHECK_ENABLED && \
277  ABTU_unlikely(p == (ABTI_future *)NULL)) { \
278  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_FUTURE); \
279  return ABT_ERR_INV_FUTURE; \
280  } \
281  } while (0)
282 
283 #define ABTI_CHECK_NULL_EVENTUAL_PTR(p) \
284  do { \
285  if (ABTI_IS_ERROR_CHECK_ENABLED && \
286  ABTU_unlikely(p == (ABTI_eventual *)NULL)) { \
287  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_EVENTUAL); \
288  return ABT_ERR_INV_EVENTUAL; \
289  } \
290  } while (0)
291 
292 #define ABTI_CHECK_NULL_BARRIER_PTR(p) \
293  do { \
294  if (ABTI_IS_ERROR_CHECK_ENABLED && \
295  ABTU_unlikely(p == (ABTI_barrier *)NULL)) { \
296  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_BARRIER); \
297  return ABT_ERR_INV_BARRIER; \
298  } \
299  } while (0)
300 
301 #define ABTI_CHECK_NULL_XSTREAM_BARRIER_PTR(p) \
302  do { \
303  if (ABTI_IS_ERROR_CHECK_ENABLED && \
304  ABTU_unlikely(p == (ABTI_xstream_barrier *)NULL)) { \
305  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_XSTREAM_BARRIER); \
306  return ABT_ERR_INV_XSTREAM_BARRIER; \
307  } \
308  } while (0)
309 
310 #define ABTI_CHECK_NULL_TIMER_PTR(p) \
311  do { \
312  if (ABTI_IS_ERROR_CHECK_ENABLED && \
313  ABTU_unlikely(p == (ABTI_timer *)NULL)) { \
314  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_TIMER); \
315  return ABT_ERR_INV_TIMER; \
316  } \
317  } while (0)
318 
319 #define ABTI_CHECK_NULL_TOOL_CONTEXT_PTR(p) \
320  do { \
321  if (ABTI_IS_ERROR_CHECK_ENABLED && \
322  ABTU_unlikely(p == (ABTI_tool_context *)NULL)) { \
323  HANDLE_ERROR_FUNC_WITH_CODE(ABT_ERR_INV_TOOL_CONTEXT); \
324  return ABT_ERR_INV_TOOL_CONTEXT; \
325  } \
326  } while (0)
327 
328 #endif /* ABTI_ERROR_H_INCLUDED */