src/gmxlib/thread_mpi/nothreads.c

   1 /*
   2 This source code file is part of thread_mpi.
   3 Written by Sander Pronk, Erik Lindahl, and possibly others.
   4
   5 Copyright (c) 2009, Sander Pronk, Erik Lindahl.
   6 All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10 1) Redistributions of source code must retain the above copyright
  11    notice, this list of conditions and the following disclaimer.
  12 2) Redistributions in binary form must reproduce the above copyright
  13    notice, this list of conditions and the following disclaimer in the
  14    documentation and/or other materials provided with the distribution.
  15 3) Neither the name of the copyright holders nor the
  16    names of its contributors may be used to endorse or promote products
  17    derived from this software without specific prior written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY US ''AS IS'' AND ANY
  20 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22 DISCLAIMED. IN NO EVENT SHALL WE BE LIABLE FOR ANY
  23 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 If you want to redistribute modifications, please consider that
  31 scientific software is very special. Version control is crucial -
  32 bugs must be traceable. We will be happy to consider code for
  33 inclusion in the official distribution, but derived work should not
  34 be called official thread_mpi. Details are found in the README & COPYING
  35 files.
  36
  37 To help us fund development, we humbly ask that you cite
  38 any papers on the package - you can find them in the top README file.
  39
  40 */
  41
  42 #ifdef HAVE_CONFIG_H
  43 #include <config.h>
  44 #endif
  45
  46 /* Hide this implementation from Doxygen, since it conflicts with pthreads */
  47 #ifndef DOXYGEN
  48
  49 #if ! (defined(THREAD_PTHREADS) || defined(THREAD_WINDOWS))
  50
  51 #include "thread_mpi/thread.h"
  52
  53
  54 #ifdef HAVE_UNISTD_H
  55 #include <unistd.h>
  56 #endif
  57
  58 #include <stdlib.h>
  59 #include <stdio.h>
  60 #include <errno.h>
  61
  62 #include "tMPI_Fatal_error.h"
  63
  64 /* Number of thread-specific storage elements.
  65  *
  66  * It might seem stupid to make the length constant instead of dynamic,
  67  * but e.g. the Pthreads standard only guarantees 128 key entries, so for
  68  * portability we shouldn't use more.
  69  */
  70 #define TMPI_THREAD_NOTHREADS_NSPECIFICDATA 128
  71
  72
  73 /*
  74  * Static variables used to keep track of thread-private data
  75  * when we are compiling without thread support. This is actually quite
  76  * simple - we just keep a list of structures with the value (pointer)
  77  * and destructor.
  78  *
  79  */
  80 static struct
  81 {
  82     int            used;                 /*!< 1 if this element is used, 0 if it is free */
  83     void *         value;                /*!< Pointer to the specific data for key n     */
  84     void          (*destructor)(void *); /*!< Pointer to destructor function for key n   */
  85 }
  86 tMPI_Thread_nothreads_specificdata[TMPI_THREAD_NOTHREADS_NSPECIFICDATA];
  87
  88
  89 /*! \brief flag to determine if static key storage has been initialized.
  90 */
  91 static int
  92 tMPI_Thread_nothreads_specific_init_done = 0;
  93
  94
  95
  96 /* Dummy implementation of abstract thread datatype */
  97 struct tMPI_Thread
  98 {
  99     int      locked; /* Just useful for debugging */
 100 };
 101
 102
 103
 104
 105 /* Dummy implementation of abstract thread-specific data key type */
 106 struct tMPI_Thread_key
 107 {
 108     int      index;  /*!< Index into our static list of private data */
 109 };
 110
 111
 112
 113
 114 enum tMPI_Thread_support
 115 tMPI_Thread_support(void)
 116 {
 117     return TMPI_THREAD_SUPPORT_NO;
 118 }
 119
 120
 121
 122 int
 123 tMPI_Thread_create   (tMPI_Thread_t *    thread,
 124                      void *            (*start_routine)(void *),
 125                      void *            arg)
 126 {
 127     tMPI_Fatal_error(FARGS,"Cannot start threads without thread support.\n");
 128
 129     return 0;
 130 }
 131
 132
 133
 134 int
 135 tMPI_Thread_join     (tMPI_Thread_t     thread,
 136                      void **          value_ptr)
 137 {
 138     tMPI_Fatal_error(FARGS,"Cannot join threads without thread support.\n");
 139
 140     return 0;
 141 }
 142
 143
 144
 145
 146 int
 147 tMPI_Thread_mutex_init(tMPI_Thread_mutex_t *mtx)
 148 {
 149     if(mtx==NULL)
 150     {
 151         return EINVAL;
 152     }
 153
 154     /* We use an integer as a mutex for debugging. */
 155     mtx->actual_mutex = malloc(sizeof(int));
 156
 157     if(mtx->actual_mutex==NULL)
 158     {
 159         fprintf(stderr,
 160                 "error [%s, line %d]: Failed to allocate mutex memory.\n",
 161                 __FILE__,__LINE__);
 162         fflush(stderr);
 163         return ENOMEM;
 164     }
 165
 166     * ( (int *) (mtx->actual_mutex) ) = 0;  /* Unlocked */
 167
 168     mtx->status = TMPI_THREAD_ONCE_STATUS_READY;
 169
 170     return 0;
 171 }
 172
 173
 174
 175 int
 176 tMPI_Thread_mutex_destroy(tMPI_Thread_mutex_t *mtx)
 177 {
 178     if(mtx == NULL)
 179     {
 180         return EINVAL;
 181     }
 182
 183     /* Must use system free() since memory allocation depends on
 184      * messages and threads working.
 185      */
 186     free(mtx->actual_mutex);
 187
 188     return 0;
 189 }
 190
 191
 192
 193
 194 static int
 195 tMPI_Thread_mutex_init_once(tMPI_Thread_mutex_t *mtx)
 196 {
 197     int rc;
 198     /* No threads = nothing to worry about */
 199     if(mtx->status != TMPI_THREAD_ONCE_STATUS_READY)
 200         rc = tMPI_Thread_mutex_init(mtx);
 201     else
 202         rc = 0;
 203
 204     return rc;
 205 }
 206
 207
 208
 209 int
 210 tMPI_Thread_mutex_lock(tMPI_Thread_mutex_t *mtx)
 211 {
 212     /* Ccheck whether this mutex is initialized */
 213     if(mtx->status != TMPI_THREAD_ONCE_STATUS_READY)
 214     {
 215         tMPI_Thread_mutex_init_once(mtx);
 216     }
 217
 218     /* The mutex is now guaranteed to be valid. */
 219     * ( (int *) (mtx->actual_mutex) ) = 1;
 220
 221     return 0;
 222 }
 223
 224
 225
 226
 227 int
 228 tMPI_Thread_mutex_trylock(tMPI_Thread_mutex_t *mtx)
 229 {
 230     int ret;
 231     int *p;
 232
 233     /* Ccheck whether this mutex is initialized */
 234     if(mtx->status != TMPI_THREAD_ONCE_STATUS_READY)
 235     {
 236         tMPI_Thread_mutex_init_once(mtx);
 237     }
 238
 239     p = (int *) (mtx->actual_mutex);
 240
 241     if( *p == 0 )
 242     {
 243         *p = 1;
 244         ret = 0;
 245     }
 246     else
 247     {
 248         ret = EBUSY;
 249     }
 250
 251     return ret;
 252 }
 253
 254
 255
 256 int
 257 tMPI_Thread_mutex_unlock(tMPI_Thread_mutex_t *mtx)
 258 {
 259     * ( (int *) (mtx->actual_mutex) ) = 0;  /* Unlocked */
 260
 261     return 0;
 262 }
 263
 264
 265
 266 int
 267 tMPI_Thread_key_create(tMPI_Thread_key_t *       key,
 268                       void                   (*destructor)(void *))
 269 {
 270     int i;
 271
 272     if(key==NULL)
 273     {
 274         fprintf(stderr,
 275                 "error [%s, line %d]: Invalid key pointer.\n",
 276                 __FILE__,__LINE__);
 277         fflush(stderr);
 278         return EINVAL;
 279     }
 280
 281     /*
 282      * Allocate memory for the pthread key. We must use the system malloc
 283      * here since the other memory allocation depends on tMPI_Thread.h.
 284      */
 285     *key = malloc(sizeof(struct tMPI_Thread_key));
 286
 287     if(*key==NULL)
 288     {
 289         fprintf(stderr,
 290                 "error [%s, line %d]: Failed to allocate thread key memory.\n",
 291                 __FILE__,__LINE__);
 292         fflush(stderr);
 293         return ENOMEM;
 294     }
 295
 296     if( tMPI_Thread_nothreads_specific_init_done == 0)
 297     {
 298
 299         for(i=0;i<TMPI_THREAD_NOTHREADS_NSPECIFICDATA;i++)
 300         {
 301             tMPI_Thread_nothreads_specificdata[i].used       = 0;
 302             tMPI_Thread_nothreads_specificdata[i].value      = NULL;
 303             tMPI_Thread_nothreads_specificdata[i].destructor = NULL;
 304         }
 305
 306         tMPI_Thread_nothreads_specific_init_done = 1;
 307     }
 308
 309     /* Try to find an empty spot */
 310     for(i=0;i<TMPI_THREAD_NOTHREADS_NSPECIFICDATA;i++)
 311     {
 312         if(tMPI_Thread_nothreads_specificdata[i].used == 0)
 313             break;
 314     }
 315
 316     if(i==TMPI_THREAD_NOTHREADS_NSPECIFICDATA)
 317     {
 318         tMPI_Fatal_error(FARGS,"Already used all %d private data keys.\n");
 319         return -1;
 320     }
 321
 322     tMPI_Thread_nothreads_specificdata[i].used = 1;
 323     (*key)->index = i;
 324
 325         return 0;
 326 }
 327
 328
 329 int
 330 tMPI_Thread_key_delete(tMPI_Thread_key_t        key)
 331 {
 332     int      i;
 333     void *   value;
 334     void    (*destructor)(void *);
 335
 336     if ( tMPI_Thread_nothreads_specific_init_done == 0 || key == NULL)
 337     {
 338         return EINVAL;
 339     }
 340
 341     i = key->index;
 342
 343     if(tMPI_Thread_nothreads_specificdata[i].value != NULL)
 344     {
 345         destructor = tMPI_Thread_nothreads_specificdata[i].destructor;
 346         value      = tMPI_Thread_nothreads_specificdata[i].value;
 347         (*destructor)(value);
 348     }
 349
 350     free(key);
 351
 352     return 0;
 353 }
 354
 355
 356
 357 void *
 358 tMPI_Thread_getspecific(tMPI_Thread_key_t  key)
 359 {
 360     if ( tMPI_Thread_nothreads_specific_init_done == 0 || key == NULL)
 361     {
 362         return NULL;
 363     }
 364
 365     return tMPI_Thread_nothreads_specificdata[key->index].value;
 366 }
 367
 368
 369 int
 370 tMPI_Thread_setspecific(tMPI_Thread_key_t    key,
 371                        void *              value)
 372 {
 373
 374     if ( tMPI_Thread_nothreads_specific_init_done == 0 || key == NULL)
 375     {
 376         return EINVAL;
 377     }
 378
 379     tMPI_Thread_nothreads_specificdata[key->index].value = value;
 380
 381     return 0;
 382 }
 383
 384
 385
 386 int
 387 tMPI_Thread_once(tMPI_Thread_once_t *     once_control,
 388                 void                    (*init_routine)(void))
 389 {
 390     if(once_control->status != TMPI_THREAD_ONCE_STATUS_READY)
 391     {
 392         (*init_routine)();
 393         once_control->status = TMPI_THREAD_ONCE_STATUS_READY;
 394     }
 395
 396     return 0;
 397 }
 398
 399
 400
 401
 402
 403 int
 404 tMPI_Thread_cond_init(tMPI_Thread_cond_t *   cond)
 405 {
 406     int ret;
 407
 408     /* Condition variables are completely useless without threads, since
 409      * we cannot wait for some signal to happen if we are the only thread
 410      * executing.
 411      *
 412      * Still, as long as we don't try to call the wait routine it won't hurt,
 413      * and we want the contents to be clean for debugging.
 414      */
 415     cond->actual_cond = NULL;
 416     cond->status = TMPI_THREAD_ONCE_STATUS_READY;
 417
 418     return 0;
 419 }
 420
 421
 422 int
 423 tMPI_Thread_cond_destroy(tMPI_Thread_cond_t *   cond)
 424 {
 425     if(cond == NULL)
 426     {
 427         return EINVAL;
 428     }
 429
 430     return 0;
 431 }
 432
 433
 434
 435
 436 static int
 437 tMPI_Thread_cond_init_once(tMPI_Thread_cond_t *     cond)
 438 {
 439     /* No threads = nothing to worry about */
 440     if(cond->status != TMPI_THREAD_ONCE_STATUS_READY)
 441         return tMPI_Thread_cond_init(cond);
 442 }
 443
 444
 445
 446 int
 447 tMPI_Thread_cond_wait(tMPI_Thread_cond_t *   cond,
 448                      tMPI_Thread_mutex_t *  mtx)
 449 {
 450     tMPI_Fatal_error(FARGS,"Called tMPI_Thread_cond_wait() without thread support. This is a major\n"
 451               "error, since nobody else can signal the condition variable - exiting.\n");
 452
 453     return 0;
 454 }
 455
 456
 457
 458
 459 int
 460 tMPI_Thread_cond_broadcast(tMPI_Thread_cond_t *   cond)
 461 {
 462     tMPI_Fatal_error(FARGS,"Called tMPI_Thread_broadcast() without thread support.\n");
 463
 464     return 0;
 465 }
 466
 467
 468
 469
 470 void
 471 tMPI_Thread_exit(void *      value_ptr)
 472 {
 473     tMPI_Fatal_error(FARGS,"Called tMPI_Thread_exit() without thread support.\n");
 474 }
 475
 476
 477
 478
 479 int
 480 tMPI_Thread_cancel(tMPI_Thread_t    thread)
 481 {
 482     tMPI_Fatal_error(FARGS,"Called tMPI_Thread_cancel() without thread support.\n");
 483
 484     return 0;
 485 }
 486
 487
 488
 489 int
 490 tMPI_Thread_barrier_init(tMPI_Thread_barrier_t *    barrier,
 491                         int                       n)
 492 {
 493     /* Barriers don't do anything without multiple threads */
 494     return 0;
 495 }
 496
 497
 498 int
 499 tMPI_Thread_barrier_destroy(tMPI_Thread_barrier_t *    barrier)
 500 {
 501     /* Barriers don't do anything without multiple threads */
 502     return 0;
 503 }
 504
 505
 506 int
 507 tMPI_Thread_barrier_wait(tMPI_Thread_barrier_t *    barrier)
 508 {
 509     /* Barriers don't do anything without multiple threads.
 510      * Since we are the only thread we're the master!
 511      */
 512     return -1;
 513 }
 514
 515
 516
 517
 518 void
 519 tMPI_lockfile(FILE *    stream)
 520 {
 521     /* Nothing to worry about without threads */
 522     return;
 523 }
 524
 525
 526 void
 527 tMPI_unlockfile(FILE *   stream)
 528 {
 529     /* Nothing to worry about without threads */
 530     return;
 531 }
 532
 533
 534
 535
 536 #endif /* ifndef DOXYGEN */
 537
 538 #endif /* no threads */