tests/test-asyncsafe-spin2.c

   1 /* Test of spin locks for communication between threads and signal handlers.
   2    Copyright (C) 2005, 2008-2020 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2005.  */
  18
  19 #include <config.h>
  20
  21 #if USE_ISOC_THREADS || USE_POSIX_THREADS || USE_ISOC_AND_POSIX_THREADS || USE_WINDOWS_THREADS
  22
  23 /* Whether to enable locking.
  24    Uncomment this to get a test program without locking, to verify that
  25    it crashes.  */
  26 #define ENABLE_LOCKING 1
  27
  28 /* Whether to help the scheduler through explicit yield().
  29    Uncomment this to see if the operating system has a fair scheduler.  */
  30 #define EXPLICIT_YIELD 1
  31
  32 /* Whether to print debugging messages.  */
  33 #define ENABLE_DEBUGGING 0
  34
  35 /* Number of simultaneous threads.  */
  36 #define THREAD_COUNT 10
  37
  38 /* Number of operations performed in each thread.  */
  39 #if !(defined _WIN32 && ! defined __CYGWIN__) && HAVE_PTHREAD_H && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && !defined __ibmxl__
  40 /* The GCC built-ins are known to work fine.  */
  41 # define REPEAT_COUNT 5000
  42 #else
  43 /* This is quite high, because with a smaller count, say 50000, we often get
  44    an "OK" result even with the racy implementation that we pick on Fedora 13
  45    Linux/x86_64 (gcc 4.4).  */
  46 # define REPEAT_COUNT 100000
  47 #endif
  48
  49 #include <signal.h>
  50 #include <stdint.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54
  55 #include "asyncsafe-spin.h"
  56 #if !ENABLE_LOCKING
  57 # define asyncsafe_spin_init(lock) (void)(lock)
  58 # define asyncsafe_spin_lock(lock, mask, saved_mask) \
  59     ((void)(lock), (void)(mask), (void)(saved_mask))
  60 # define asyncsafe_spin_unlock(lock, saved_mask) \
  61     ((void)(lock), (void)(saved_mask))
  62 # define asyncsafe_spin_destroy(lock) (void)(lock)
  63 #endif
  64
  65 #include "glthread/lock.h"
  66 #include "glthread/thread.h"
  67 #include "glthread/yield.h"
  68
  69 #if HAVE_DECL_ALARM
  70 # include <signal.h>
  71 # include <unistd.h>
  72 #endif
  73
  74 #include "atomic-int-gnulib.h"
  75
  76 #if ENABLE_DEBUGGING
  77 # define dbgprintf printf
  78 #else
  79 # define dbgprintf if (0) printf
  80 #endif
  81
  82 #if EXPLICIT_YIELD
  83 # define yield() gl_thread_yield ()
  84 #else
  85 # define yield()
  86 #endif
  87
  88 static sigset_t signals_to_block;
  89
  90 #define ACCOUNT_COUNT 4
  91
  92 static int account[ACCOUNT_COUNT];
  93
  94 static int
  95 random_account (void)
  96 {
  97   return ((unsigned int) rand () >> 3) % ACCOUNT_COUNT;
  98 }
  99
 100 static void
 101 check_accounts (void)
 102 {
 103   int i, sum;
 104
 105   sum = 0;
 106   for (i = 0; i < ACCOUNT_COUNT; i++)
 107     sum += account[i];
 108   if (sum != ACCOUNT_COUNT * 1000)
 109     abort ();
 110 }
 111
 112
 113 /* ------------------- Test use like normal locks ------------------- */
 114
 115 /* Test normal locks by having several bank accounts and several threads
 116    which shuffle around money between the accounts and another thread
 117    checking that all the money is still there.  */
 118
 119 static asyncsafe_spinlock_t my_lock;
 120
 121 static void *
 122 lock_mutator_thread (void *arg)
 123 {
 124   int repeat;
 125
 126   for (repeat = REPEAT_COUNT; repeat > 0; repeat--)
 127     {
 128       sigset_t saved_signals;
 129       int i1, i2, value;
 130
 131       dbgprintf ("Mutator %p before lock\n", gl_thread_self_pointer ());
 132       asyncsafe_spin_lock (&my_lock, &signals_to_block, &saved_signals);
 133       dbgprintf ("Mutator %p after  lock\n", gl_thread_self_pointer ());
 134
 135       i1 = random_account ();
 136       i2 = random_account ();
 137       value = ((unsigned int) rand () >> 3) % 10;
 138       account[i1] += value;
 139       account[i2] -= value;
 140
 141       dbgprintf ("Mutator %p before unlock\n", gl_thread_self_pointer ());
 142       asyncsafe_spin_unlock (&my_lock, &saved_signals);
 143       dbgprintf ("Mutator %p after  unlock\n", gl_thread_self_pointer ());
 144
 145       dbgprintf ("Mutator %p before check lock\n", gl_thread_self_pointer ());
 146       asyncsafe_spin_lock (&my_lock, &signals_to_block, &saved_signals);
 147       check_accounts ();
 148       asyncsafe_spin_unlock (&my_lock, &saved_signals);
 149       dbgprintf ("Mutator %p after  check unlock\n", gl_thread_self_pointer ());
 150
 151       yield ();
 152     }
 153
 154   dbgprintf ("Mutator %p dying.\n", gl_thread_self_pointer ());
 155   return NULL;
 156 }
 157
 158 static struct atomic_int lock_checker_done;
 159
 160 static void *
 161 lock_checker_thread (void *arg)
 162 {
 163   while (get_atomic_int_value (&lock_checker_done) == 0)
 164     {
 165       sigset_t saved_signals;
 166
 167       dbgprintf ("Checker %p before check lock\n", gl_thread_self_pointer ());
 168       asyncsafe_spin_lock (&my_lock, &signals_to_block, &saved_signals);
 169       check_accounts ();
 170       asyncsafe_spin_unlock (&my_lock, &saved_signals);
 171       dbgprintf ("Checker %p after  check unlock\n", gl_thread_self_pointer ());
 172
 173       yield ();
 174     }
 175
 176   dbgprintf ("Checker %p dying.\n", gl_thread_self_pointer ());
 177   return NULL;
 178 }
 179
 180 static void
 181 test_asyncsafe_spin (void)
 182 {
 183   int i;
 184   gl_thread_t checkerthread;
 185   gl_thread_t threads[THREAD_COUNT];
 186
 187   /* Initialization.  */
 188   for (i = 0; i < ACCOUNT_COUNT; i++)
 189     account[i] = 1000;
 190   init_atomic_int (&lock_checker_done);
 191   set_atomic_int_value (&lock_checker_done, 0);
 192
 193   /* Spawn the threads.  */
 194   checkerthread = gl_thread_create (lock_checker_thread, NULL);
 195   for (i = 0; i < THREAD_COUNT; i++)
 196     threads[i] = gl_thread_create (lock_mutator_thread, NULL);
 197
 198   /* Wait for the threads to terminate.  */
 199   for (i = 0; i < THREAD_COUNT; i++)
 200     gl_thread_join (threads[i], NULL);
 201   set_atomic_int_value (&lock_checker_done, 1);
 202   gl_thread_join (checkerthread, NULL);
 203   check_accounts ();
 204 }
 205
 206
 207 /* -------------------------------------------------------------------------- */
 208
 209 int
 210 main ()
 211 {
 212 #if HAVE_DECL_ALARM
 213   /* Declare failure if test takes too long, by using default abort
 214      caused by SIGALRM.  */
 215   int alarm_value = 600;
 216   signal (SIGALRM, SIG_DFL);
 217   alarm (alarm_value);
 218 #endif
 219
 220   sigemptyset (&signals_to_block);
 221   sigaddset (&signals_to_block, SIGINT);
 222
 223   asyncsafe_spin_init (&my_lock);
 224
 225   printf ("Starting test_asyncsafe_spin ..."); fflush (stdout);
 226   test_asyncsafe_spin ();
 227   printf (" OK\n"); fflush (stdout);
 228
 229   return 0;
 230 }
 231
 232 #else
 233
 234 /* No multithreading available.  */
 235
 236 #include <stdio.h>
 237
 238 int
 239 main ()
 240 {
 241   fputs ("Skipping test: multithreading not enabled\n", stderr);
 242   return 77;
 243 }
 244
 245 #endif