tests/test-cnd.c

   1 /* Test of condition variables in multithreaded situations.
   2    Copyright (C) 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 #include <config.h>
  18
  19 /* Which tests to perform.
  20    Uncomment some of these, to verify that all tests crash if no locking
  21    is enabled.  */
  22 #define DO_TEST_COND 1
  23 #define DO_TEST_TIMEDCOND 1
  24
  25
  26 /* Whether to help the scheduler through explicit thrd_yield().
  27    Uncomment this to see if the operating system has a fair scheduler.  */
  28 #define EXPLICIT_YIELD 1
  29
  30 /* Whether to print debugging messages.  */
  31 #define ENABLE_DEBUGGING 0
  32
  33 #include <threads.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <sys/time.h>
  38
  39 #if HAVE_DECL_ALARM
  40 # include <signal.h>
  41 # include <unistd.h>
  42 #endif
  43
  44 #include "virtualbox.h"
  45 #include "macros.h"
  46
  47 #if ENABLE_DEBUGGING
  48 # define dbgprintf printf
  49 #else
  50 # define dbgprintf if (0) printf
  51 #endif
  52
  53 #if EXPLICIT_YIELD
  54 # define yield() thrd_yield ()
  55 #else
  56 # define yield()
  57 #endif
  58
  59
  60 /*
  61  * Condition check
  62  */
  63
  64 /* Marked volatile so that different threads see the same value.  This is
  65    good enough in practice, although in theory stdatomic.h should be used.  */
  66 static int volatile cond_value;
  67 static cnd_t condtest;
  68 static mtx_t lockcond;
  69
  70 static int
  71 cnd_wait_routine (void *arg)
  72 {
  73   ASSERT (mtx_lock (&lockcond) == thrd_success);
  74   if (cond_value)
  75     {
  76       /* The main thread already slept, and nevertheless this thread comes
  77          too late.  */
  78       *(int *)arg = 1;
  79     }
  80   else
  81     {
  82       do
  83         {
  84           ASSERT (cnd_wait (&condtest, &lockcond) == thrd_success);
  85         }
  86       while (!cond_value);
  87     }
  88   ASSERT (mtx_unlock (&lockcond) == thrd_success);
  89
  90   cond_value = 2;
  91
  92   return 0;
  93 }
  94
  95 static int
  96 test_cnd_wait ()
  97 {
  98   int skipped = 0;
  99   thrd_t thread;
 100   int ret;
 101
 102   cond_value = 0;
 103
 104   /* Create a separate thread.  */
 105   ASSERT (thrd_create (&thread, cnd_wait_routine, &skipped) == thrd_success);
 106
 107   /* Sleep for 2 seconds.  */
 108   {
 109     struct timespec remaining;
 110
 111     remaining.tv_sec = 2;
 112     remaining.tv_nsec = 0;
 113
 114     do
 115       {
 116         yield ();
 117         ret = thrd_sleep (&remaining, &remaining);
 118         ASSERT (ret >= -1);
 119       }
 120     while (ret == -1 && (remaining.tv_sec != 0 || remaining.tv_nsec != 0));
 121   }
 122
 123   /* Tell one of the waiting threads (if any) to continue.  */
 124   ASSERT (mtx_lock (&lockcond) == thrd_success);
 125   cond_value = 1;
 126   ASSERT (cnd_signal (&condtest) == thrd_success);
 127   ASSERT (mtx_unlock (&lockcond) == thrd_success);
 128
 129   ASSERT (thrd_join (thread, NULL) == thrd_success);
 130
 131   if (cond_value != 2)
 132     abort ();
 133
 134   return skipped;
 135 }
 136
 137
 138 /*
 139  * Timed Condition check
 140  */
 141
 142 /* Marked volatile so that different threads see the same value.  This is
 143    good enough in practice, although in theory stdatomic.h should be used.  */
 144 static int volatile cond_timed_out;
 145
 146 /* Stores in *TS the current time plus 1 second.  */
 147 static void
 148 get_ts (struct timespec *ts)
 149 {
 150   struct timeval now;
 151
 152   gettimeofday (&now, NULL);
 153
 154   ts->tv_sec = now.tv_sec + 1;
 155   ts->tv_nsec = now.tv_usec * 1000;
 156 }
 157
 158 static int
 159 cnd_timedwait_routine (void *arg)
 160 {
 161   int ret;
 162   struct timespec ts;
 163
 164   ASSERT (mtx_lock (&lockcond) == thrd_success);
 165   if (cond_value)
 166     {
 167       /* The main thread already slept, and nevertheless this thread comes
 168          too late.  */
 169       *(int *)arg = 1;
 170     }
 171   else
 172     {
 173       do
 174         {
 175           get_ts (&ts);
 176           ret = cnd_timedwait (&condtest, &lockcond, &ts);
 177           if (ret == thrd_timedout)
 178             cond_timed_out = 1;
 179         }
 180       while (!cond_value);
 181     }
 182   ASSERT (mtx_unlock (&lockcond) == thrd_success);
 183
 184   return 0;
 185 }
 186
 187 static int
 188 test_cnd_timedwait (void)
 189 {
 190   int skipped = 0;
 191   thrd_t thread;
 192   int ret;
 193
 194   cond_value = cond_timed_out = 0;
 195
 196   /* Create a separate thread.  */
 197   ASSERT (thrd_create (&thread, cnd_timedwait_routine, &skipped)
 198           == thrd_success);
 199
 200   /* Sleep for 2 seconds.  */
 201   {
 202     struct timespec remaining;
 203
 204     remaining.tv_sec = 2;
 205     remaining.tv_nsec = 0;
 206
 207     do
 208       {
 209         yield ();
 210         ret = thrd_sleep (&remaining, &remaining);
 211         ASSERT (ret >= -1);
 212       }
 213     while (ret == -1 && (remaining.tv_sec != 0 || remaining.tv_nsec != 0));
 214   }
 215
 216   /* Tell one of the waiting threads (if any) to continue.  */
 217   ASSERT (mtx_lock (&lockcond) == thrd_success);
 218   cond_value = 1;
 219   ASSERT (cnd_signal (&condtest) == thrd_success);
 220   ASSERT (mtx_unlock (&lockcond) == thrd_success);
 221
 222   ASSERT (thrd_join (thread, NULL) == thrd_success);
 223
 224   if (!cond_timed_out)
 225     abort ();
 226
 227   return skipped;
 228 }
 229
 230
 231 int
 232 main ()
 233 {
 234   /* This test occasionally fails on Linux (glibc or musl libc), in a
 235      VirtualBox VM with paravirtualization = Default or KVM, with ≥ 2 CPUs.
 236      Skip the test in this situation.  */
 237   if (is_running_under_virtualbox_kvm () && num_cpus () > 1)
 238     {
 239       fputs ("Skipping test: avoiding VirtualBox bug with KVM paravirtualization\n",
 240              stderr);
 241       return 77;
 242     }
 243
 244 #if HAVE_DECL_ALARM
 245   /* Declare failure if test takes too long, by using default abort
 246      caused by SIGALRM.  */
 247   int alarm_value = 600;
 248   signal (SIGALRM, SIG_DFL);
 249   alarm (alarm_value);
 250 #endif
 251
 252   ASSERT (cnd_init (&condtest) == thrd_success);
 253   ASSERT (mtx_init (&lockcond, mtx_plain) == thrd_success);
 254
 255 #if DO_TEST_COND
 256   printf ("Starting test_cnd_wait ..."); fflush (stdout);
 257   {
 258     int skipped = test_cnd_wait ();
 259     printf (skipped ? " SKIP\n" : " OK\n"); fflush (stdout);
 260   }
 261 #endif
 262 #if DO_TEST_TIMEDCOND
 263   printf ("Starting test_cnd_timedwait ..."); fflush (stdout);
 264   {
 265     int skipped = test_cnd_timedwait ();
 266     printf (skipped ? " SKIP\n" : " OK\n"); fflush (stdout);
 267   }
 268 #endif
 269
 270   return test_exit_status;
 271 }