1 /* Copyright (C) 2018-2023 Free Software Foundation, Inc.
2 Contributed by Nicolas Koenig
3
4 This file is part of the GNU Fortran runtime library (libgfortran).
5
6 Libgfortran is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 Libgfortran is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 Under Section 7 of GPL version 3, you are granted additional
17 permissions described in the GCC Runtime Library Exception, version
18 3.1, as published by the Free Software Foundation.
19
20 You should have received a copy of the GNU General Public License and
21 a copy of the GCC Runtime Library Exception along with this program;
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 <http://www.gnu.org/licenses/>. */
24
25 #ifndef ASYNC_H
26 #define ASYNC_H
27
28 /* Async I/O will not work on targets which do not support
29 __gthread_cond_t and __gthread_equal / __gthread_self. Check
30 this. */
31
32 #if defined(__GTHREAD_HAS_COND) && defined(__GTHREADS_CXX0X)
33 #define ASYNC_IO 1
34 #else
35 #define ASYNC_IO 0
36 #endif
37
38 /* Defining DEBUG_ASYNC will enable somewhat verbose debugging
39 output for async I/O. */
40
41 #define DEBUG_ASYNC
42 #undef DEBUG_ASYNC
43
44 #ifdef DEBUG_ASYNC
45
46 /* Define this if you want to use ANSI color escape sequences in your
47 debugging output. */
48
49 #define DEBUG_COLOR
50
51 #ifdef DEBUG_COLOR
52 #define MPREFIX "\033[30;46mM:\033[0m "
53 #define TPREFIX "\033[37;44mT:\033[0m "
54 #define RPREFIX "\033[37;41mR:\033[0m "
55 #define DEBUG_RED "\033[31m"
56 #define DEBUG_ORANGE "\033[33m"
57 #define DEBUG_GREEN "\033[32m"
58 #define DEBUG_DARKRED "\033[31;2m"
59 #define DEBUG_PURPLE "\033[35m"
60 #define DEBUG_NORM "\033[0m"
61 #define DEBUG_REVERSE_RED "\033[41;37m"
62 #define DEBUG_BLUE "\033[34m"
63
64 #else
65
66 #define MPREFIX "M: "
67 #define TPREFIX "T: "
68 #define RPREFIX ""
69 #define DEBUG_RED ""
70 #define DEBUG_ORANGE ""
71 #define DEBUG_GREEN ""
72 #define DEBUG_DARKRED ""
73 #define DEBUG_PURPLE ""
74 #define DEBUG_NORM ""
75 #define DEBUG_REVERSE_RED ""
76 #define DEBUG_BLUE ""
77
78 #endif
79
80 #define DEBUG_PRINTF(...) fprintf (stderr,__VA_ARGS__)
81
82 #define IN_DEBUG_QUEUE(mutex) ({ \
83 __label__ end; \
84 aio_lock_debug *curr = aio_debug_head; \
85 while (curr) { \
86 if (curr->m == mutex) { \
87 goto end; \
88 } \
89 curr = curr->next; \
90 } \
91 end:; \
92 curr; \
93 })
94
95 #define TAIL_DEBUG_QUEUE ({ \
96 aio_lock_debug *curr = aio_debug_head; \
97 while (curr && curr->next) { \
98 curr = curr->next; \
99 } \
100 curr; \
101 })
102
103 #define CHECK_LOCK(mutex, status) do { \
104 aio_lock_debug *curr; \
105 INTERN_LOCK (&debug_queue_lock); \
106 if (__gthread_mutex_trylock (mutex)) { \
107 if ((curr = IN_DEBUG_QUEUE (mutex))) { \
108 sprintf (status, DEBUG_RED "%s():%d" DEBUG_NORM, curr->func, curr->line); \
109 } else \
110 sprintf (status, DEBUG_RED "unknown" DEBUG_NORM); \
111 } \
112 else { \
113 __gthread_mutex_unlock (mutex); \
114 sprintf (status, DEBUG_GREEN "unlocked" DEBUG_NORM); \
115 } \
116 INTERN_UNLOCK (&debug_queue_lock); \
117 }while (0)
118
119 #define T_ERROR(func, ...) do { \
120 int t_error_temp; \
121 t_error_temp = func(__VA_ARGS__); \
122 if (t_error_temp) \
123 ERROR (t_error_temp, "args: " #__VA_ARGS__ "\n"); \
124 } while (0)
125
126 #define NOTE(str, ...) do{ \
127 char note_str[200]; \
128 sprintf (note_str, "%s" DEBUG_PURPLE "NOTE: " DEBUG_NORM str, aio_prefix, ##__VA_ARGS__); \
129 DEBUG_PRINTF ("%-90s %20s():%-5d\n", note_str, __FUNCTION__, __LINE__); \
130 }while (0);
131
132 #define ERROR(errnum, str, ...) do{ \
133 char note_str[200]; \
134 sprintf (note_str, "%s" DEBUG_REVERSE_RED "ERROR:" DEBUG_NORM " [%d] " str, aio_prefix, \
135 errnum, ##__VA_ARGS__); \
136 DEBUG_PRINTF ("%-68s %s():%-5d\n", note_str, __FUNCTION__, __LINE__); \
137 }while (0)
138
139 #define MUTEX_DEBUG_ADD(mutex) do { \
140 aio_lock_debug *n; \
141 n = malloc (sizeof(aio_lock_debug)); \
142 n->prev = TAIL_DEBUG_QUEUE; \
143 if (n->prev) \
144 n->prev->next = n; \
145 n->next = NULL; \
146 n->line = __LINE__; \
147 n->func = __FUNCTION__; \
148 n->m = mutex; \
149 if (!aio_debug_head) { \
150 aio_debug_head = n; \
151 } \
152 } while (0)
153
154 #define UNLOCK(mutex) do { \
155 aio_lock_debug *curr; \
156 DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_GREEN "UNLOCK: " DEBUG_NORM #mutex, \
157 __FUNCTION__, __LINE__, (void *) mutex); \
158 INTERN_LOCK (&debug_queue_lock); \
159 curr = IN_DEBUG_QUEUE (mutex); \
160 if (curr) \
161 { \
162 if (curr->prev) \
163 curr->prev->next = curr->next; \
164 if (curr->next) { \
165 curr->next->prev = curr->prev; \
166 if (curr == aio_debug_head) \
167 aio_debug_head = curr->next; \
168 } else { \
169 if (curr == aio_debug_head) \
170 aio_debug_head = NULL; \
171 } \
172 free (curr); \
173 } \
174 INTERN_UNLOCK (&debug_queue_lock); \
175 INTERN_UNLOCK (mutex); \
176 }while (0)
177
178 #define TRYLOCK(mutex) ({ \
179 char status[200]; \
180 int res; \
181 aio_lock_debug *curr; \
182 res = __gthread_mutex_trylock (mutex); \
183 INTERN_LOCK (&debug_queue_lock); \
184 if (res) { \
185 if ((curr = IN_DEBUG_QUEUE (mutex))) { \
186 sprintf (status, DEBUG_RED "%s():%d" DEBUG_NORM, curr->func, curr->line); \
187 } else \
188 sprintf (status, DEBUG_RED "unknown" DEBUG_NORM); \
189 } \
190 else { \
191 sprintf (status, DEBUG_GREEN "unlocked" DEBUG_NORM); \
192 MUTEX_DEBUG_ADD (mutex); \
193 } \
194 DEBUG_PRINTF ("%s%-44s prev: %-35s %20s():%-5d %18p\n", aio_prefix, \
195 DEBUG_DARKRED "TRYLOCK: " DEBUG_NORM #mutex, status, __FUNCTION__, __LINE__, \
196 (void *) mutex); \
197 INTERN_UNLOCK (&debug_queue_lock); \
198 res; \
199 })
200
201 #define LOCK(mutex) do { \
202 char status[200]; \
203 CHECK_LOCK (mutex, status); \
204 DEBUG_PRINTF ("%s%-42s prev: %-35s %20s():%-5d %18p\n", aio_prefix, \
205 DEBUG_RED "LOCK: " DEBUG_NORM #mutex, status, __FUNCTION__, __LINE__, (void *) mutex); \
206 INTERN_LOCK (mutex); \
207 INTERN_LOCK (&debug_queue_lock); \
208 MUTEX_DEBUG_ADD (mutex); \
209 INTERN_UNLOCK (&debug_queue_lock); \
210 DEBUG_PRINTF ("%s" DEBUG_RED "ACQ:" DEBUG_NORM " %-30s %78p\n", aio_prefix, #mutex, mutex); \
211 } while (0)
212
213 #define DEBUG_LINE(...) __VA_ARGS__
214
215 #else
216 #define DEBUG_PRINTF(...) {}
217 #define CHECK_LOCK(au, mutex, status) {}
218 #define NOTE(str, ...) {}
219 #define DEBUG_LINE(...)
220 #define T_ERROR(func, ...) func(__VA_ARGS__)
221 #define LOCK(mutex) INTERN_LOCK (mutex)
222 #define UNLOCK(mutex) INTERN_UNLOCK (mutex)
223 #define TRYLOCK(mutex) (__gthread_mutex_trylock (mutex))
224 #endif
225
226 #define INTERN_LOCK(mutex) T_ERROR (__gthread_mutex_lock, mutex);
227
228 #define INTERN_UNLOCK(mutex) T_ERROR (__gthread_mutex_unlock, mutex);
229
230 #if ASYNC_IO
231
232 /* au->lock has to be held when calling this macro. */
233
234 #define SIGNAL(advcond) do{ \
235 (advcond)->pending = 1; \
236 DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_ORANGE "SIGNAL: " DEBUG_NORM \
237 #advcond, __FUNCTION__, __LINE__, (void *) advcond); \
238 T_ERROR (__gthread_cond_broadcast, &(advcond)->signal); \
239 } while (0)
240
241 /* Has to be entered with mutex locked. */
242
243 #define WAIT_SIGNAL_MUTEX(advcond, condition, mutex) do{ \
244 __label__ finish; \
245 DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_BLUE "WAITING: " DEBUG_NORM \
246 #advcond, __FUNCTION__, __LINE__, (void *) advcond); \
247 if ((advcond)->pending || (condition)) \
248 goto finish; \
249 while (1) \
250 { \
251 int err_ret = __gthread_cond_wait(&(advcond)->signal, mutex); \
252 if (err_ret) internal_error (NULL, "WAIT_SIGNAL_MUTEX failed"); \
253 if (condition) \
254 { \
255 DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_ORANGE \
256 "REC: " DEBUG_NORM \
257 #advcond, __FUNCTION__, __LINE__, (void *)advcond); \
258 break; \
259 } \
260 } \
261 finish: \
262 (advcond)->pending = 0; \
263 UNLOCK (mutex); \
264 } while (0)
265
266 /* au->lock has to be held when calling this macro. */
267
268 #define REVOKE_SIGNAL(advcond) do{ \
269 (advcond)->pending = 0; \
270 } while (0)
271
272 #else
273
274 #define SIGNAL(advcond) do{} while(0)
275 #define WAIT_SIGNAL_MUTEX(advcond, condition, mutex) do{} while(0)
276 #define REVOKE_SIGNAL(advcond) do{} while(0)
277
278 #endif
279
280 #if ASYNC_IO
281 DEBUG_LINE (extern __thread const char *aio_prefix);
282
283 DEBUG_LINE (typedef struct aio_lock_debug{
284 __gthread_mutex_t *m;
285 int line;
286 const char *func;
287 struct aio_lock_debug *next;
288 struct aio_lock_debug *prev;
289 } aio_lock_debug;)
290
291 DEBUG_LINE (extern aio_lock_debug *aio_debug_head;)
292 DEBUG_LINE (extern __gthread_mutex_t debug_queue_lock;)
293
294 /* Thread - local storage of the current unit we are looking at. Needed for
295 error reporting. */
296
297 extern __thread gfc_unit *thread_unit;
298 #endif
299
300 enum aio_do {
301 AIO_INVALID = 0,
302 AIO_DATA_TRANSFER_INIT,
303 AIO_TRANSFER_SCALAR,
304 AIO_TRANSFER_ARRAY,
305 AIO_WRITE_DONE,
306 AIO_READ_DONE,
307 AIO_CLOSE
308 };
309
310 typedef union transfer_args
311 {
312 struct
313 {
314 void (*transfer) (struct st_parameter_dt *, bt, void *, int, size_t, size_t);
315 bt arg_bt;
316 void *data;
317 int i;
318 size_t s1;
319 size_t s2;
320 } scalar;
321 struct
322 {
323 gfc_array_char *desc;
324 int kind;
325 gfc_charlen_type charlen;
326 } array;
327 } transfer_args;
328
329 struct adv_cond
330 {
331 #if ASYNC_IO
332 int pending;
333 __gthread_cond_t signal;
334 #endif
335 };
336
337 typedef struct async_unit
338 {
339 __gthread_mutex_t io_lock; /* Lock for doing actual I/O. */
340 __gthread_mutex_t lock; /* Lock for manipulating the queue structure. */
341 bool empty;
342 struct
343 {
344 int waiting;
345 int low;
346 int high;
347 struct adv_cond done;
348 } id;
349
350 #if ASYNC_IO
351 struct adv_cond work;
352 struct adv_cond emptysignal;
353 struct st_parameter_dt *pdt;
354 __gthread_t thread;
355 struct transfer_queue *head;
356 struct transfer_queue *tail;
357
358 struct {
359 const char *message;
360 st_parameter_common *cmp;
361 bool has_error;
362 int last_good_id;
363 int family;
364 bool fatal_error;
365 } error;
366 #endif
367 } async_unit;
368
369 void init_async_unit (gfc_unit *);
370 internal_proto (init_async_unit);
371
372 bool async_wait (st_parameter_common *, async_unit *);
373 internal_proto (async_wait);
374
375 bool async_wait_id (st_parameter_common *, async_unit *, int);
376 internal_proto (async_wait_id);
377
378 bool collect_async_errors (st_parameter_common *, async_unit *);
379 internal_proto (collect_async_errors);
380
381 void async_close (async_unit *);
382 internal_proto (async_close);
383
384 void enqueue_transfer (async_unit * au, transfer_args * arg, enum aio_do);
385 internal_proto (enqueue_transfer);
386
387 void enqueue_done (async_unit *, enum aio_do type);
388 internal_proto (enqueue_done);
389
390 int enqueue_done_id (async_unit *, enum aio_do type);
391 internal_proto (enqueue_done_id);
392
393 void enqueue_init (async_unit *);
394 internal_proto (enqueue_init);
395
396 void enqueue_data_transfer_init (async_unit *, st_parameter_dt *, int);
397 internal_proto (enqueue_data_transfer_init);
398
399 void enqueue_close (async_unit *);
400 internal_proto (enqueue_close);
401
402 #endif