libgfortran/io/async.h

   1 /* Copyright (C) 2018 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 #define SIGNAL(advcond) do{                                             \
 233     INTERN_LOCK (&(advcond)->lock);                                     \
 234     (advcond)->pending = 1;                                             \
 235     DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_ORANGE "SIGNAL: " DEBUG_NORM \
 236                  #advcond, __FUNCTION__, __LINE__, (void *) advcond);   \
 237     T_ERROR (__gthread_cond_broadcast, &(advcond)->signal);             \
 238     INTERN_UNLOCK (&(advcond)->lock);                                   \
 239   } while (0)
 240
 241 #define WAIT_SIGNAL_MUTEX(advcond, condition, mutex) do{                \
 242     __label__ finish;                                                   \
 243     INTERN_LOCK (&((advcond)->lock));                                   \
 244     DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_BLUE "WAITING: " DEBUG_NORM \
 245                  #advcond, __FUNCTION__, __LINE__, (void *) advcond);   \
 246     if ((advcond)->pending || (condition)){                             \
 247       UNLOCK (mutex);                                                   \
 248       goto finish;                                                      \
 249     }                                                                   \
 250     UNLOCK (mutex);                                                     \
 251      while (!__gthread_cond_wait(&(advcond)->signal, &(advcond)->lock)) {       \
 252        { int cond;                                                      \
 253          LOCK (mutex); cond = condition; UNLOCK (mutex);        \
 254            if (cond){                                                   \
 255              DEBUG_PRINTF ("%s%-75s %20s():%-5d %18p\n", aio_prefix, DEBUG_ORANGE "REC: " DEBUG_NORM \
 256                   #advcond,  __FUNCTION__, __LINE__, (void *)advcond);  \
 257            break;                                                       \
 258         }                                                       \
 259       }                                                                 \
 260     }                                                                   \
 261   finish:                                                               \
 262                  (advcond)->pending = 0;                                \
 263                  INTERN_UNLOCK (&((advcond)->lock));                    \
 264                  } while (0)
 265
 266 #define REVOKE_SIGNAL(advcond) do{              \
 267     INTERN_LOCK (&(advcond)->lock);             \
 268     (advcond)->pending = 0;                     \
 269     INTERN_UNLOCK (&(advcond)->lock);           \
 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_mutex_t lock;
 334   __gthread_cond_t signal;
 335 #endif
 336 };
 337
 338 typedef struct async_unit
 339 {
 340   __gthread_mutex_t io_lock;   /* Lock for doing actual I/O. */
 341   __gthread_mutex_t lock;      /* Lock for manipulating the queue structure.  */
 342   bool empty;
 343   struct
 344   {
 345     int waiting;
 346     int low;
 347     int high;
 348     struct adv_cond done;
 349   } id;
 350
 351 #if ASYNC_IO
 352   struct adv_cond work;
 353   struct adv_cond emptysignal;
 354   struct st_parameter_dt *pdt;
 355   pthread_t thread;
 356   struct transfer_queue *head;
 357   struct transfer_queue *tail;
 358
 359   struct {
 360     const char *message;
 361     st_parameter_common *cmp;
 362     bool has_error;
 363     int last_good_id;
 364     int family;
 365     bool fatal_error;
 366   } error;
 367 #endif
 368 } async_unit;
 369
 370 void init_async_unit (gfc_unit *);
 371 internal_proto (init_async_unit);
 372
 373 bool async_wait (st_parameter_common *, async_unit *);
 374 internal_proto (async_wait);
 375
 376 bool async_wait_id (st_parameter_common *, async_unit *, int);
 377 internal_proto (async_wait_id);
 378
 379 bool collect_async_errors (st_parameter_common *, async_unit *);
 380 internal_proto (collect_async_errors);
 381
 382 void async_close (async_unit *);
 383 internal_proto (async_close);
 384
 385 void enqueue_transfer (async_unit * au, transfer_args * arg, enum aio_do);
 386 internal_proto (enqueue_transfer);
 387
 388 void enqueue_done (async_unit *, enum aio_do type);
 389 internal_proto (enqueue_done);
 390
 391 int enqueue_done_id (async_unit *, enum aio_do type);
 392 internal_proto (enqueue_done_id);
 393
 394 void enqueue_init (async_unit *);
 395 internal_proto (enqueue_init);
 396
 397 void enqueue_data_transfer_init (async_unit *, st_parameter_dt *, int);
 398 internal_proto (enqueue_data_transfer_init);
 399
 400 void enqueue_close (async_unit *);
 401 internal_proto (enqueue_close);
 402
 403 #endif