Move remaining call_once tests from mtx-tests to call_once-tests.

* tests/test-call_once1.c: Renamed from tests/test-call_once.c.
* tests/test-call_once2.c: New file, based on tests/test-mtx.c.
* tests/test-mtx.c: Remove the code that was testing call_once.
* modules/call_once-tests (Files): Add test-call_once1.c,
test-call_once2.c. Remove test-call_once.c.
(Depends-on): Add thrd, lock, stdint.
(configure.ac): Check for alarm.
(Makefile.am): Test test-call_once1 instead of test-call_once. Also test
test-call_once2.

3 files changed, 255 insertions, 160 deletions

diff --git a/tests/test-call_once.c b/tests/test-call_once1.c
index 6f515e42c7..6f515e42c7 100644
--- a/tests/test-call_once.c
+++ b/tests/test-call_once1.c
diff --git a/tests/test-call_once2.c b/tests/test-call_once2.c
new file mode 100644
index 0000000000..19cf2b575e
--- /dev/null
+++ b/tests/test-call_once2.c
@@ -0,0 +1,255 @@
+/* Test of locking in multithreaded situations.
+   Copyright (C) 2005, 2008-2023 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by Bruno Haible <bruno@clisp.org>, 2005.  */
+
+#include <config.h>
+
+/* Whether to enable locking.
+   Uncomment this to get a test program without locking, to verify that
+   it crashes.  */
+#define ENABLE_LOCKING 1
+
+/* Whether to help the scheduler through explicit thrd_yield().
+   Uncomment this to see if the operating system has a fair scheduler.  */
+#define EXPLICIT_YIELD 1
+
+/* Whether to print debugging messages.  */
+#define ENABLE_DEBUGGING 0
+
+/* Number of simultaneous threads.  */
+#define THREAD_COUNT 10
+
+/* Number of operations performed in each thread.
+   This is quite high, because with a smaller count, say 5000, we often get
+   an "OK" result even without ENABLE_LOCKING (on Linux/x86).  */
+#define REPEAT_COUNT 50000
+
+#include <threads.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "glthread/lock.h"
+
+#if HAVE_DECL_ALARM
+# include <signal.h>
+# include <unistd.h>
+#endif
+
+#include "macros.h"
+
+#if ENABLE_DEBUGGING
+# define dbgprintf printf
+#else
+# define dbgprintf if (0) printf
+#endif
+
+#if EXPLICIT_YIELD
+# define yield() thrd_yield ()
+#else
+# define yield()
+#endif
+
+/* Returns a reference to the current thread as a pointer, for debugging.  */
+#if defined __MVS__
+  /* On IBM z/OS, pthread_t is a struct with an 8-byte '__' field.
+     The first three bytes of this field appear to uniquely identify a
+     pthread_t, though not necessarily representing a pointer.  */
+# define thrd_current_pointer() (*((void **) thrd_current ().__))
+#elif defined __sun
+  /* On Solaris, thrd_t is merely an 'unsigned int'.  */
+# define thrd_current_pointer() ((void *) (uintptr_t) thrd_current ())
+#else
+# define thrd_current_pointer() ((void *) thrd_current ())
+#endif
+
+
+/* ------------------------ Test once-only execution ------------------------ */
+
+/* Test once-only execution by having several threads attempt to grab a
+   once-only task simultaneously (triggered by releasing a read-write lock).  */
+
+static once_flag fresh_once = ONCE_FLAG_INIT;
+static int ready[THREAD_COUNT];
+static mtx_t ready_lock[THREAD_COUNT];
+#if ENABLE_LOCKING
+static gl_rwlock_t fire_signal[REPEAT_COUNT];
+#else
+static volatile int fire_signal_state;
+#endif
+static once_flag once_control;
+static int performed;
+static mtx_t performed_lock;
+
+static void
+once_execute (void)
+{
+  ASSERT (mtx_lock (&performed_lock) == thrd_success);
+  performed++;
+  ASSERT (mtx_unlock (&performed_lock) == thrd_success);
+}
+
+static int
+once_contender_thread (void *arg)
+{
+  int id = (int) (intptr_t) arg;
+  int repeat;
+
+  for (repeat = 0; repeat <= REPEAT_COUNT; repeat++)
+    {
+      /* Tell the main thread that we're ready.  */
+      ASSERT (mtx_lock (&ready_lock[id]) == thrd_success);
+      ready[id] = 1;
+      ASSERT (mtx_unlock (&ready_lock[id]) == thrd_success);
+
+      if (repeat == REPEAT_COUNT)
+        break;
+
+      dbgprintf ("Contender %p waiting for signal for round %d\n",
+                 thrd_current_pointer (), repeat);
+#if ENABLE_LOCKING
+      /* Wait for the signal to go.  */
+      gl_rwlock_rdlock (fire_signal[repeat]);
+      /* And don't hinder the others (if the scheduler is unfair).  */
+      gl_rwlock_unlock (fire_signal[repeat]);
+#else
+      /* Wait for the signal to go.  */
+      while (fire_signal_state <= repeat)
+        yield ();
+#endif
+      dbgprintf ("Contender %p got the     signal for round %d\n",
+                 thrd_current_pointer (), repeat);
+
+      /* Contend for execution.  */
+      call_once (&once_control, once_execute);
+    }
+
+  return 0;
+}
+
+static void
+test_once (void)
+{
+  int i, repeat;
+  thrd_t threads[THREAD_COUNT];
+
+  /* Initialize all variables.  */
+  for (i = 0; i < THREAD_COUNT; i++)
+    {
+      ready[i] = 0;
+      ASSERT (mtx_init (&ready_lock[i], mtx_plain) == thrd_success);
+    }
+#if ENABLE_LOCKING
+  for (i = 0; i < REPEAT_COUNT; i++)
+    gl_rwlock_init (fire_signal[i]);
+#else
+  fire_signal_state = 0;
+#endif
+
+#if ENABLE_LOCKING
+  /* Block all fire_signals.  */
+  for (i = REPEAT_COUNT-1; i >= 0; i--)
+    gl_rwlock_wrlock (fire_signal[i]);
+#endif
+
+  /* Spawn the threads.  */
+  for (i = 0; i < THREAD_COUNT; i++)
+    ASSERT (thrd_create (&threads[i],
+                         once_contender_thread, (void *) (intptr_t) i)
+            == thrd_success);
+
+  for (repeat = 0; repeat <= REPEAT_COUNT; repeat++)
+    {
+      /* Wait until every thread is ready.  */
+      dbgprintf ("Main thread before synchronizing for round %d\n", repeat);
+      for (;;)
+        {
+          int ready_count = 0;
+          for (i = 0; i < THREAD_COUNT; i++)
+            {
+              ASSERT (mtx_lock (&ready_lock[i]) == thrd_success);
+              ready_count += ready[i];
+              ASSERT (mtx_unlock (&ready_lock[i]) == thrd_success);
+            }
+          if (ready_count == THREAD_COUNT)
+            break;
+          yield ();
+        }
+      dbgprintf ("Main thread after  synchronizing for round %d\n", repeat);
+
+      if (repeat > 0)
+        {
+          /* Check that exactly one thread executed the once_execute()
+             function.  */
+          if (performed != 1)
+            abort ();
+        }
+
+      if (repeat == REPEAT_COUNT)
+        break;
+
+      /* Preparation for the next round: Initialize once_control.  */
+      memcpy (&once_control, &fresh_once, sizeof (once_flag));
+
+      /* Preparation for the next round: Reset the performed counter.  */
+      performed = 0;
+
+      /* Preparation for the next round: Reset the ready flags.  */
+      for (i = 0; i < THREAD_COUNT; i++)
+        {
+          ASSERT (mtx_lock (&ready_lock[i]) == thrd_success);
+          ready[i] = 0;
+          ASSERT (mtx_unlock (&ready_lock[i]) == thrd_success);
+        }
+
+      /* Signal all threads simultaneously.  */
+      dbgprintf ("Main thread giving signal for round %d\n", repeat);
+#if ENABLE_LOCKING
+      gl_rwlock_unlock (fire_signal[repeat]);
+#else
+      fire_signal_state = repeat + 1;
+#endif
+    }
+
+  /* Wait for the threads to terminate.  */
+  for (i = 0; i < THREAD_COUNT; i++)
+    ASSERT (thrd_join (threads[i], NULL) == thrd_success);
+}
+
+
+/* -------------------------------------------------------------------------- */
+
+int
+main ()
+{
+#if HAVE_DECL_ALARM
+  /* Declare failure if test takes too long, by using default abort
+     caused by SIGALRM.  */
+  int alarm_value = 600;
+  signal (SIGALRM, SIG_DFL);
+  alarm (alarm_value);
+#endif
+
+  ASSERT (mtx_init (&performed_lock, mtx_plain) == thrd_success);
+
+  printf ("Starting test_once ..."); fflush (stdout);
+  test_once ();
+  printf (" OK\n"); fflush (stdout);
+
+  return 0;
+}
diff --git a/tests/test-mtx.c b/tests/test-mtx.c
index 128c403720..b00a9a554a 100644
--- a/tests/test-mtx.c
+++ b/tests/test-mtx.c
@@ -28,7 +28,6 @@
    is enabled.  */
 #define DO_TEST_LOCK 1
 #define DO_TEST_RECURSIVE_LOCK 1
-#define DO_TEST_ONCE 1
 
 /* Whether to help the scheduler through explicit thrd_yield().
    Uncomment this to see if the operating system has a fair scheduler.  */
@@ -305,159 +304,6 @@ test_mtx_recursive (void)
 }
 
 
-/* ------------------------ Test once-only execution ------------------------ */
-
-/* Test once-only execution by having several threads attempt to grab a
-   once-only task simultaneously (triggered by releasing a read-write lock).  */
-
-static once_flag fresh_once = ONCE_FLAG_INIT;
-static int ready[THREAD_COUNT];
-static mtx_t ready_lock[THREAD_COUNT];
-#if ENABLE_LOCKING
-static gl_rwlock_t fire_signal[REPEAT_COUNT];
-#else
-static volatile int fire_signal_state;
-#endif
-static once_flag once_control;
-static int performed;
-static mtx_t performed_lock;
-
-static void
-once_execute (void)
-{
-  ASSERT (mtx_lock (&performed_lock) == thrd_success);
-  performed++;
-  ASSERT (mtx_unlock (&performed_lock) == thrd_success);
-}
-
-static int
-once_contender_thread (void *arg)
-{
-  int id = (int) (intptr_t) arg;
-  int repeat;
-
-  for (repeat = 0; repeat <= REPEAT_COUNT; repeat++)
-    {
-      /* Tell the main thread that we're ready.  */
-      ASSERT (mtx_lock (&ready_lock[id]) == thrd_success);
-      ready[id] = 1;
-      ASSERT (mtx_unlock (&ready_lock[id]) == thrd_success);
-
-      if (repeat == REPEAT_COUNT)
-        break;
-
-      dbgprintf ("Contender %p waiting for signal for round %d\n",
-                 thrd_current_pointer (), repeat);
-#if ENABLE_LOCKING
-      /* Wait for the signal to go.  */
-      gl_rwlock_rdlock (fire_signal[repeat]);
-      /* And don't hinder the others (if the scheduler is unfair).  */
-      gl_rwlock_unlock (fire_signal[repeat]);
-#else
-      /* Wait for the signal to go.  */
-      while (fire_signal_state <= repeat)
-        yield ();
-#endif
-      dbgprintf ("Contender %p got the     signal for round %d\n",
-                 thrd_current_pointer (), repeat);
-
-      /* Contend for execution.  */
-      call_once (&once_control, once_execute);
-    }
-
-  return 0;
-}
-
-static void
-test_once (void)
-{
-  int i, repeat;
-  thrd_t threads[THREAD_COUNT];
-
-  /* Initialize all variables.  */
-  for (i = 0; i < THREAD_COUNT; i++)
-    {
-      ready[i] = 0;
-      ASSERT (mtx_init (&ready_lock[i], mtx_plain) == thrd_success);
-    }
-#if ENABLE_LOCKING
-  for (i = 0; i < REPEAT_COUNT; i++)
-    gl_rwlock_init (fire_signal[i]);
-#else
-  fire_signal_state = 0;
-#endif
-
-#if ENABLE_LOCKING
-  /* Block all fire_signals.  */
-  for (i = REPEAT_COUNT-1; i >= 0; i--)
-    gl_rwlock_wrlock (fire_signal[i]);
-#endif
-
-  /* Spawn the threads.  */
-  for (i = 0; i < THREAD_COUNT; i++)
-    ASSERT (thrd_create (&threads[i],
-                         once_contender_thread, (void *) (intptr_t) i)
-            == thrd_success);
-
-  for (repeat = 0; repeat <= REPEAT_COUNT; repeat++)
-    {
-      /* Wait until every thread is ready.  */
-      dbgprintf ("Main thread before synchronizing for round %d\n", repeat);
-      for (;;)
-        {
-          int ready_count = 0;
-          for (i = 0; i < THREAD_COUNT; i++)
-            {
-              ASSERT (mtx_lock (&ready_lock[i]) == thrd_success);
-              ready_count += ready[i];
-              ASSERT (mtx_unlock (&ready_lock[i]) == thrd_success);
-            }
-          if (ready_count == THREAD_COUNT)
-            break;
-          yield ();
-        }
-      dbgprintf ("Main thread after  synchronizing for round %d\n", repeat);
-
-      if (repeat > 0)
-        {
-          /* Check that exactly one thread executed the once_execute()
-             function.  */
-          if (performed != 1)
-            abort ();
-        }
-
-      if (repeat == REPEAT_COUNT)
-        break;
-
-      /* Preparation for the next round: Initialize once_control.  */
-      memcpy (&once_control, &fresh_once, sizeof (once_flag));
-
-      /* Preparation for the next round: Reset the performed counter.  */
-      performed = 0;
-
-      /* Preparation for the next round: Reset the ready flags.  */
-      for (i = 0; i < THREAD_COUNT; i++)
-        {
-          ASSERT (mtx_lock (&ready_lock[i]) == thrd_success);
-          ready[i] = 0;
-          ASSERT (mtx_unlock (&ready_lock[i]) == thrd_success);
-        }
-
-      /* Signal all threads simultaneously.  */
-      dbgprintf ("Main thread giving signal for round %d\n", repeat);
-#if ENABLE_LOCKING
-      gl_rwlock_unlock (fire_signal[repeat]);
-#else
-      fire_signal_state = repeat + 1;
-#endif
-    }
-
-  /* Wait for the threads to terminate.  */
-  for (i = 0; i < THREAD_COUNT; i++)
-    ASSERT (thrd_join (threads[i], NULL) == thrd_success);
-}
-
-
 /* -------------------------------------------------------------------------- */
 
 int
@@ -473,7 +319,6 @@ main ()
 
   ASSERT (mtx_init (&my_lock, mtx_plain) == thrd_success);
   ASSERT (mtx_init (&my_reclock, mtx_plain | mtx_recursive) == thrd_success);
-  ASSERT (mtx_init (&performed_lock, mtx_plain) == thrd_success);
 
 #if DO_TEST_LOCK
   printf ("Starting test_mtx_plain ..."); fflush (stdout);
@@ -485,11 +330,6 @@ main ()
   test_mtx_recursive ();
   printf (" OK\n"); fflush (stdout);
 #endif
-#if DO_TEST_ONCE
-  printf ("Starting test_once ..."); fflush (stdout);
-  test_once ();
-  printf (" OK\n"); fflush (stdout);
-#endif
 
   return 0;
 }