tests/test-mtx.c

   1 /* Test of locking in multithreaded situations.
   2    Copyright (C) 2005, 2008-2024 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 /* Whether to enable locking.
  22    Uncomment this to get a test program without locking, to verify that
  23    it crashes.  */
  24 #define ENABLE_LOCKING 1
  25
  26 /* Which tests to perform.
  27    Uncomment some of these, to verify that all tests crash if no locking
  28    is enabled.  */
  29 #define DO_TEST_LOCK 1
  30 #define DO_TEST_RECURSIVE_LOCK 1
  31
  32 /* Whether to help the scheduler through explicit thrd_yield().
  33    Uncomment this to see if the operating system has a fair scheduler.  */
  34 #define EXPLICIT_YIELD 1
  35
  36 /* Whether to print debugging messages.  */
  37 #define ENABLE_DEBUGGING 0
  38
  39 /* Number of simultaneous threads.  */
  40 #define THREAD_COUNT 10
  41
  42 /* Number of operations performed in each thread.
  43    This is quite high, because with a smaller count, say 5000, we often get
  44    an "OK" result even without ENABLE_LOCKING (on Linux/x86).  */
  45 #define REPEAT_COUNT 50000
  46
  47 #include <threads.h>
  48 #include <stdint.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52
  53 #include "glthread/lock.h"
  54
  55 #if HAVE_DECL_ALARM
  56 # include <signal.h>
  57 # include <unistd.h>
  58 #endif
  59
  60 #include "macros.h"
  61 #include "atomic-int-isoc.h"
  62
  63 #if ENABLE_DEBUGGING
  64 # define dbgprintf printf
  65 #else
  66 # define dbgprintf if (0) printf
  67 #endif
  68
  69 #if EXPLICIT_YIELD
  70 # define yield() thrd_yield ()
  71 #else
  72 # define yield()
  73 #endif
  74
  75 /* Returns a reference to the current thread as a pointer, for debugging.  */
  76 #if defined __MVS__
  77   /* On IBM z/OS, pthread_t is a struct with an 8-byte '__' field.
  78      The first three bytes of this field appear to uniquely identify a
  79      pthread_t, though not necessarily representing a pointer.  */
  80 # define thrd_current_pointer() (*((void **) thrd_current ().__))
  81 #elif defined __sun
  82   /* On Solaris, thrd_t is merely an 'unsigned int'.  */
  83 # define thrd_current_pointer() ((void *) (uintptr_t) thrd_current ())
  84 #else
  85 # define thrd_current_pointer() ((void *) thrd_current ())
  86 #endif
  87
  88 #define ACCOUNT_COUNT 4
  89
  90 static int account[ACCOUNT_COUNT];
  91
  92 static int
  93 random_account (void)
  94 {
  95   return ((unsigned long) random () >> 3) % ACCOUNT_COUNT;
  96 }
  97
  98 static void
  99 check_accounts (void)
 100 {
 101   int i, sum;
 102
 103   sum = 0;
 104   for (i = 0; i < ACCOUNT_COUNT; i++)
 105     sum += account[i];
 106   if (sum != ACCOUNT_COUNT * 1000)
 107     abort ();
 108 }
 109
 110
 111 /* ------------------- Test normal (non-recursive) locks ------------------- */
 112
 113 /* Test normal locks by having several bank accounts and several threads
 114    which shuffle around money between the accounts and another thread
 115    checking that all the money is still there.  */
 116
 117 static mtx_t my_lock;
 118
 119 static int
 120 lock_mutator_thread (void *arg)
 121 {
 122   int repeat;
 123
 124   for (repeat = REPEAT_COUNT; repeat > 0; repeat--)
 125     {
 126       int i1, i2, value;
 127
 128       dbgprintf ("Mutator %p before lock\n", thrd_current_pointer ());
 129       ASSERT (mtx_lock (&my_lock) == thrd_success);
 130       dbgprintf ("Mutator %p after  lock\n", thrd_current_pointer ());
 131
 132       i1 = random_account ();
 133       i2 = random_account ();
 134       value = ((unsigned long) random () >> 3) % 10;
 135       account[i1] += value;
 136       account[i2] -= value;
 137
 138       dbgprintf ("Mutator %p before unlock\n", thrd_current_pointer ());
 139       ASSERT (mtx_unlock (&my_lock) == thrd_success);
 140       dbgprintf ("Mutator %p after  unlock\n", thrd_current_pointer ());
 141
 142       dbgprintf ("Mutator %p before check lock\n", thrd_current_pointer ());
 143       ASSERT (mtx_lock (&my_lock) == thrd_success);
 144       check_accounts ();
 145       ASSERT (mtx_unlock (&my_lock) == thrd_success);
 146       dbgprintf ("Mutator %p after  check unlock\n", thrd_current_pointer ());
 147
 148       yield ();
 149     }
 150
 151   dbgprintf ("Mutator %p dying.\n", thrd_current_pointer ());
 152   return 0;
 153 }
 154
 155 static struct atomic_int lock_checker_done;
 156
 157 static int
 158 lock_checker_thread (void *arg)
 159 {
 160   while (get_atomic_int_value (&lock_checker_done) == 0)
 161     {
 162       dbgprintf ("Checker %p before check lock\n", thrd_current_pointer ());
 163       ASSERT (mtx_lock (&my_lock) == thrd_success);
 164       check_accounts ();
 165       ASSERT (mtx_unlock (&my_lock) == thrd_success);
 166       dbgprintf ("Checker %p after  check unlock\n", thrd_current_pointer ());
 167
 168       yield ();
 169     }
 170
 171   dbgprintf ("Checker %p dying.\n", thrd_current_pointer ());
 172   return 0;
 173 }
 174
 175 static void
 176 test_mtx_plain (void)
 177 {
 178   int i;
 179   thrd_t checkerthread;
 180   thrd_t threads[THREAD_COUNT];
 181
 182   /* Initialization.  */
 183   for (i = 0; i < ACCOUNT_COUNT; i++)
 184     account[i] = 1000;
 185   init_atomic_int (&lock_checker_done);
 186   set_atomic_int_value (&lock_checker_done, 0);
 187
 188   /* Spawn the threads.  */
 189   ASSERT (thrd_create (&checkerthread, lock_checker_thread, NULL)
 190           == thrd_success);
 191   for (i = 0; i < THREAD_COUNT; i++)
 192     ASSERT (thrd_create (&threads[i], lock_mutator_thread, NULL)
 193             == thrd_success);
 194
 195   /* Wait for the threads to terminate.  */
 196   for (i = 0; i < THREAD_COUNT; i++)
 197     ASSERT (thrd_join (threads[i], NULL) == thrd_success);
 198   set_atomic_int_value (&lock_checker_done, 1);
 199   ASSERT (thrd_join (checkerthread, NULL) == thrd_success);
 200   check_accounts ();
 201 }
 202
 203
 204 /* -------------------------- Test recursive locks -------------------------- */
 205
 206 /* Test recursive locks by having several bank accounts and several threads
 207    which shuffle around money between the accounts (recursively) and another
 208    thread checking that all the money is still there.  */
 209
 210 static mtx_t my_reclock;
 211
 212 static void
 213 recshuffle (void)
 214 {
 215   int i1, i2, value;
 216
 217   dbgprintf ("Mutator %p before lock\n", thrd_current_pointer ());
 218   ASSERT (mtx_lock (&my_reclock) == thrd_success);
 219   dbgprintf ("Mutator %p after  lock\n", thrd_current_pointer ());
 220
 221   i1 = random_account ();
 222   i2 = random_account ();
 223   value = ((unsigned long) random () >> 3) % 10;
 224   account[i1] += value;
 225   account[i2] -= value;
 226
 227   /* Recursive with probability 0.5.  */
 228   if (((unsigned long) random () >> 3) % 2)
 229     recshuffle ();
 230
 231   dbgprintf ("Mutator %p before unlock\n", thrd_current_pointer ());
 232   ASSERT (mtx_unlock (&my_reclock) == thrd_success);
 233   dbgprintf ("Mutator %p after  unlock\n", thrd_current_pointer ());
 234 }
 235
 236 static int
 237 reclock_mutator_thread (void *arg)
 238 {
 239   int repeat;
 240
 241   for (repeat = REPEAT_COUNT; repeat > 0; repeat--)
 242     {
 243       recshuffle ();
 244
 245       dbgprintf ("Mutator %p before check lock\n", thrd_current_pointer ());
 246       ASSERT (mtx_lock (&my_reclock) == thrd_success);
 247       check_accounts ();
 248       ASSERT (mtx_unlock (&my_reclock) == thrd_success);
 249       dbgprintf ("Mutator %p after  check unlock\n", thrd_current_pointer ());
 250
 251       yield ();
 252     }
 253
 254   dbgprintf ("Mutator %p dying.\n", thrd_current_pointer ());
 255   return 0;
 256 }
 257
 258 static struct atomic_int reclock_checker_done;
 259
 260 static int
 261 reclock_checker_thread (void *arg)
 262 {
 263   while (get_atomic_int_value (&reclock_checker_done) == 0)
 264     {
 265       dbgprintf ("Checker %p before check lock\n", thrd_current_pointer ());
 266       ASSERT (mtx_lock (&my_reclock) == thrd_success);
 267       check_accounts ();
 268       ASSERT (mtx_unlock (&my_reclock) == thrd_success);
 269       dbgprintf ("Checker %p after  check unlock\n", thrd_current_pointer ());
 270
 271       yield ();
 272     }
 273
 274   dbgprintf ("Checker %p dying.\n", thrd_current_pointer ());
 275   return 0;
 276 }
 277
 278 static void
 279 test_mtx_recursive (void)
 280 {
 281   int i;
 282   thrd_t checkerthread;
 283   thrd_t threads[THREAD_COUNT];
 284
 285   /* Initialization.  */
 286   for (i = 0; i < ACCOUNT_COUNT; i++)
 287     account[i] = 1000;
 288   init_atomic_int (&reclock_checker_done);
 289   set_atomic_int_value (&reclock_checker_done, 0);
 290
 291   /* Spawn the threads.  */
 292   ASSERT (thrd_create (&checkerthread, reclock_checker_thread, NULL)
 293           == thrd_success);
 294   for (i = 0; i < THREAD_COUNT; i++)
 295     ASSERT (thrd_create (&threads[i], reclock_mutator_thread, NULL)
 296             == thrd_success);
 297
 298   /* Wait for the threads to terminate.  */
 299   for (i = 0; i < THREAD_COUNT; i++)
 300     ASSERT (thrd_join (threads[i], NULL) == thrd_success);
 301   set_atomic_int_value (&reclock_checker_done, 1);
 302   ASSERT (thrd_join (checkerthread, NULL) == thrd_success);
 303   check_accounts ();
 304 }
 305
 306
 307 /* -------------------------------------------------------------------------- */
 308
 309 int
 310 main ()
 311 {
 312 #if HAVE_DECL_ALARM
 313   /* Declare failure if test takes too long, by using default abort
 314      caused by SIGALRM.  */
 315   int alarm_value = 600;
 316   signal (SIGALRM, SIG_DFL);
 317   alarm (alarm_value);
 318 #endif
 319
 320   ASSERT (mtx_init (&my_lock, mtx_plain) == thrd_success);
 321   ASSERT (mtx_init (&my_reclock, mtx_plain | mtx_recursive) == thrd_success);
 322
 323 #if DO_TEST_LOCK
 324   printf ("Starting test_mtx_plain ..."); fflush (stdout);
 325   test_mtx_plain ();
 326   printf (" OK\n"); fflush (stdout);
 327 #endif
 328 #if DO_TEST_RECURSIVE_LOCK
 329   printf ("Starting test_mtx_recursive ..."); fflush (stdout);
 330   test_mtx_recursive ();
 331   printf (" OK\n"); fflush (stdout);
 332 #endif
 333
 334   return test_exit_status;
 335 }