A testdir of module 'mtx' fails to build on mingw and other platforms:
/usr/x86_64-w64-mingw32/bin/ld: test-mtx.o: in function `once_contender_thread':
../../gltests/test-mtx.c:365: undefined reference to `call_once'
collect2: error: ld returned 1 exit status
make[4]: *** [Makefile:4173: test-mtx.exe] Error 1
The cause is that on 2023-03-25, I moved the function call_once out of
module 'mtx', and part of the unit tests to module 'call_once-tests'.
But some unit tests of call_once remained in module 'mtx-tests'.
This patch fixes it.
2023-04-20 Bruno Haible <br...@clisp.org>
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.
>From e524987de9c1746ad1c9d3def0adff2582545eb9 Mon Sep 17 00:00:00 2001
From: Bruno Haible <br...@clisp.org>
Date: Thu, 20 Apr 2023 14:21:09 +0200
Subject: [PATCH] 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.
---
ChangeLog | 13 +
modules/call_once-tests | 14 +-
tests/{test-call_once.c => test-call_once1.c} | 0
tests/test-call_once2.c | 255 ++++++++++++++++++
tests/test-mtx.c | 160 -----------
5 files changed, 278 insertions(+), 164 deletions(-)
rename tests/{test-call_once.c => test-call_once1.c} (100%)
create mode 100644 tests/test-call_once2.c
diff --git a/ChangeLog b/ChangeLog
index b3665c5c3b..ca6b2caf69 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2023-04-20 Bruno Haible <br...@clisp.org>
+
+ 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.
+
2023-04-20 Bruno Haible <br...@clisp.org>
execute tests: Fix compilation error on mingw (regression 2023-01-17).
diff --git a/modules/call_once-tests b/modules/call_once-tests
index 70bae25eb3..7889c9a1d7 100644
--- a/modules/call_once-tests
+++ b/modules/call_once-tests
@@ -1,12 +1,18 @@
Files:
-tests/test-call_once.c
+tests/test-call_once1.c
+tests/test-call_once2.c
tests/macros.h
Depends-on:
+thrd
+lock
+stdint
configure.ac:
+AC_CHECK_DECLS_ONCE([alarm])
Makefile.am:
-TESTS += test-call_once
-check_PROGRAMS += test-call_once
-test_call_once_LDADD = $(LDADD) @LIBSTDTHREAD@
+TESTS += test-call_once1 test-call_once2
+check_PROGRAMS += test-call_once1 test-call_once2
+test_call_once1_LDADD = $(LDADD) @LIBSTDTHREAD@
+test_call_once2_LDADD = $(LDADD) @LIBSTDTHREAD@ @LIBTHREAD@
diff --git a/tests/test-call_once.c b/tests/test-call_once1.c
similarity index 100%
rename from tests/test-call_once.c
rename to 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 <br...@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;
}
--
2.34.1
