mirror of
https://git.savannah.gnu.org/git/gnulib.git
synced 2025-08-08 17:22:05 +03:00
tests: Reduce code duplication.
* tests/atomic-int-posix.h: New file, extracted from tests/test-pthread-mutex.c. * tests/test-pthread-mutex.c: Include it. Remove the corresponding code. * tests/test-pthread-rwlock.c: Likewise. * modules/pthread-mutex-tests (Files): Add tests/atomic-int-posix.h. * modules/pthread-rwlock-tests (Files): Likewise.
This commit is contained in:
Bruno Haible
10
ChangeLog
10
ChangeLog
@@ -1,3 +1,13 @@
|
||||
2020-07-01 Bruno Haible <bruno@clisp.org>
|
||||
|
||||
tests: Reduce code duplication.
|
||||
* tests/atomic-int-posix.h: New file, extracted from
|
||||
tests/test-pthread-mutex.c.
|
||||
* tests/test-pthread-mutex.c: Include it. Remove the corresponding code.
|
||||
* tests/test-pthread-rwlock.c: Likewise.
|
||||
* modules/pthread-mutex-tests (Files): Add tests/atomic-int-posix.h.
|
||||
* modules/pthread-rwlock-tests (Files): Likewise.
|
||||
|
||||
2020-07-01 Bruno Haible <bruno@clisp.org>
|
||||
|
||||
tests: Refactor.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
Files:
|
||||
tests/test-pthread-mutex.c
|
||||
tests/atomic-int-posix.h
|
||||
tests/macros.h
|
||||
|
||||
Depends-on:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
Files:
|
||||
tests/test-pthread-rwlock.c
|
||||
tests/atomic-int-posix.h
|
||||
tests/macros.h
|
||||
|
||||
Depends-on:
|
||||
|
||||
178
tests/atomic-int-posix.h
Normal file
178
tests/atomic-int-posix.h
Normal file
@@ -0,0 +1,178 @@
|
||||
/* Atomic integers. Useful for testing multithreaded locking primitives.
|
||||
Copyright (C) 2005, 2008-2020 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/>. */
|
||||
|
||||
|
||||
/* Whether to use 'volatile' on some variables that communicate information
|
||||
between threads. If set to 0, a semaphore or a lock is used to protect
|
||||
these variables. If set to 1, 'volatile' is used; this is theoretically
|
||||
equivalent but can lead to much slower execution (e.g. 30x slower total
|
||||
run time on a 40-core machine), because 'volatile' does not imply any
|
||||
synchronization/communication between different CPUs. */
|
||||
#define USE_VOLATILE 0
|
||||
|
||||
#if USE_POSIX_THREADS && HAVE_SEMAPHORE_H
|
||||
/* Whether to use a semaphore to communicate information between threads.
|
||||
If set to 0, a lock is used. If set to 1, a semaphore is used.
|
||||
Uncomment this to reduce the dependencies of this test. */
|
||||
# define USE_SEMAPHORE 1
|
||||
/* Mac OS X provides only named semaphores (sem_open); its facility for
|
||||
unnamed semaphores (sem_init) does not work. */
|
||||
# if defined __APPLE__ && defined __MACH__
|
||||
# define USE_NAMED_SEMAPHORE 1
|
||||
# else
|
||||
# define USE_UNNAMED_SEMAPHORE 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
#if USE_SEMAPHORE
|
||||
# include <errno.h>
|
||||
# include <fcntl.h>
|
||||
# include <semaphore.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
|
||||
#if USE_VOLATILE
|
||||
struct atomic_int {
|
||||
volatile int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
return ai->value;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ai->value = new_value;
|
||||
}
|
||||
#elif USE_SEMAPHORE
|
||||
/* This atomic_int implementation can only support the values 0 and 1.
|
||||
It is initially 0 and can be set to 1 only once. */
|
||||
# if USE_UNNAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) (&(ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_init (&ai->semaphore, 0, 0);
|
||||
}
|
||||
# endif
|
||||
# if USE_NAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t *semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) ((ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_t *s;
|
||||
unsigned int count;
|
||||
for (count = 0; ; count++)
|
||||
{
|
||||
char name[80];
|
||||
/* Use getpid() in the name, so that different processes running at the
|
||||
same time will not interfere. Use ai in the name, so that different
|
||||
atomic_int in the same process will not interfere. Use a count in
|
||||
the name, so that even in the (unlikely) case that a semaphore with
|
||||
the specified name already exists, we can try a different name. */
|
||||
sprintf (name, "test-lock-%lu-%p-%u",
|
||||
(unsigned long) getpid (), ai, count);
|
||||
s = sem_open (name, O_CREAT | O_EXCL, 0600, 0);
|
||||
if (s == SEM_FAILED)
|
||||
{
|
||||
if (errno == EEXIST)
|
||||
/* Retry with a different name. */
|
||||
continue;
|
||||
else
|
||||
{
|
||||
perror ("sem_open failed");
|
||||
abort ();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Try not to leave a semaphore hanging around on the file system
|
||||
eternally, if we can avoid it. */
|
||||
sem_unlink (name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ai->semaphore = s;
|
||||
}
|
||||
# endif
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
if (sem_trywait (atomic_int_semaphore (ai)) == 0)
|
||||
{
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
return 1;
|
||||
}
|
||||
else if (errno == EAGAIN)
|
||||
return 0;
|
||||
else
|
||||
abort ();
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
if (new_value == 0)
|
||||
/* It's already initialized with 0. */
|
||||
return;
|
||||
/* To set the value 1: */
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
}
|
||||
#else
|
||||
struct atomic_int {
|
||||
pthread_mutex_t lock;
|
||||
int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
ASSERT (pthread_mutexattr_init (&attr) == 0);
|
||||
ASSERT (pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL) == 0);
|
||||
ASSERT (pthread_mutex_init (&ai->lock, &attr) == 0);
|
||||
ASSERT (pthread_mutexattr_destroy (&attr) == 0);
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
int ret = ai->value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
return ret;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
ai->value = new_value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
}
|
||||
#endif
|
||||
@@ -35,28 +35,6 @@
|
||||
Uncomment this to see if the operating system has a fair scheduler. */
|
||||
#define EXPLICIT_YIELD 1
|
||||
|
||||
/* Whether to use 'volatile' on some variables that communicate information
|
||||
between threads. If set to 0, a semaphore or a lock is used to protect
|
||||
these variables. If set to 1, 'volatile' is used; this is theoretically
|
||||
equivalent but can lead to much slower execution (e.g. 30x slower total
|
||||
run time on a 40-core machine), because 'volatile' does not imply any
|
||||
synchronization/communication between different CPUs. */
|
||||
#define USE_VOLATILE 0
|
||||
|
||||
#if USE_POSIX_THREADS && HAVE_SEMAPHORE_H
|
||||
/* Whether to use a semaphore to communicate information between threads.
|
||||
If set to 0, a lock is used. If set to 1, a semaphore is used.
|
||||
Uncomment this to reduce the dependencies of this test. */
|
||||
# define USE_SEMAPHORE 1
|
||||
/* Mac OS X provides only named semaphores (sem_open); its facility for
|
||||
unnamed semaphores (sem_init) does not work. */
|
||||
# if defined __APPLE__ && defined __MACH__
|
||||
# define USE_NAMED_SEMAPHORE 1
|
||||
# else
|
||||
# define USE_UNNAMED_SEMAPHORE 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Whether to print debugging messages. */
|
||||
#define ENABLE_DEBUGGING 0
|
||||
|
||||
@@ -78,19 +56,13 @@
|
||||
# include <sched.h>
|
||||
#endif
|
||||
|
||||
#if USE_SEMAPHORE
|
||||
# include <errno.h>
|
||||
# include <fcntl.h>
|
||||
# include <semaphore.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_DECL_ALARM
|
||||
# include <signal.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include "macros.h"
|
||||
#include "atomic-int-posix.h"
|
||||
|
||||
#if ENABLE_DEBUGGING
|
||||
# define dbgprintf printf
|
||||
@@ -104,137 +76,6 @@
|
||||
# define yield()
|
||||
#endif
|
||||
|
||||
#if USE_VOLATILE
|
||||
struct atomic_int {
|
||||
volatile int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
return ai->value;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ai->value = new_value;
|
||||
}
|
||||
#elif USE_SEMAPHORE
|
||||
/* This atomic_int implementation can only support the values 0 and 1.
|
||||
It is initially 0 and can be set to 1 only once. */
|
||||
# if USE_UNNAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) (&(ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_init (&ai->semaphore, 0, 0);
|
||||
}
|
||||
# endif
|
||||
# if USE_NAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t *semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) ((ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_t *s;
|
||||
unsigned int count;
|
||||
for (count = 0; ; count++)
|
||||
{
|
||||
char name[80];
|
||||
/* Use getpid() in the name, so that different processes running at the
|
||||
same time will not interfere. Use ai in the name, so that different
|
||||
atomic_int in the same process will not interfere. Use a count in
|
||||
the name, so that even in the (unlikely) case that a semaphore with
|
||||
the specified name already exists, we can try a different name. */
|
||||
sprintf (name, "test-lock-%lu-%p-%u",
|
||||
(unsigned long) getpid (), ai, count);
|
||||
s = sem_open (name, O_CREAT | O_EXCL, 0600, 0);
|
||||
if (s == SEM_FAILED)
|
||||
{
|
||||
if (errno == EEXIST)
|
||||
/* Retry with a different name. */
|
||||
continue;
|
||||
else
|
||||
{
|
||||
perror ("sem_open failed");
|
||||
abort ();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Try not to leave a semaphore hanging around on the file system
|
||||
eternally, if we can avoid it. */
|
||||
sem_unlink (name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ai->semaphore = s;
|
||||
}
|
||||
# endif
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
if (sem_trywait (atomic_int_semaphore (ai)) == 0)
|
||||
{
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
return 1;
|
||||
}
|
||||
else if (errno == EAGAIN)
|
||||
return 0;
|
||||
else
|
||||
abort ();
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
if (new_value == 0)
|
||||
/* It's already initialized with 0. */
|
||||
return;
|
||||
/* To set the value 1: */
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
}
|
||||
#else
|
||||
struct atomic_int {
|
||||
pthread_mutex_t lock;
|
||||
int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
ASSERT (pthread_mutexattr_init (&attr) == 0);
|
||||
ASSERT (pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL) == 0);
|
||||
ASSERT (pthread_mutex_init (&ai->lock, &attr) == 0);
|
||||
ASSERT (pthread_mutexattr_destroy (&attr) == 0);
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
int ret = ai->value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
return ret;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
ai->value = new_value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
}
|
||||
#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.
|
||||
|
||||
@@ -29,28 +29,6 @@
|
||||
Uncomment this to see if the operating system has a fair scheduler. */
|
||||
#define EXPLICIT_YIELD 1
|
||||
|
||||
/* Whether to use 'volatile' on some variables that communicate information
|
||||
between threads. If set to 0, a semaphore or a lock is used to protect
|
||||
these variables. If set to 1, 'volatile' is used; this is theoretically
|
||||
equivalent but can lead to much slower execution (e.g. 30x slower total
|
||||
run time on a 40-core machine), because 'volatile' does not imply any
|
||||
synchronization/communication between different CPUs. */
|
||||
#define USE_VOLATILE 0
|
||||
|
||||
#if USE_POSIX_THREADS && HAVE_SEMAPHORE_H
|
||||
/* Whether to use a semaphore to communicate information between threads.
|
||||
If set to 0, a lock is used. If set to 1, a semaphore is used.
|
||||
Uncomment this to reduce the dependencies of this test. */
|
||||
# define USE_SEMAPHORE 1
|
||||
/* Mac OS X provides only named semaphores (sem_open); its facility for
|
||||
unnamed semaphores (sem_init) does not work. */
|
||||
# if defined __APPLE__ && defined __MACH__
|
||||
# define USE_NAMED_SEMAPHORE 1
|
||||
# else
|
||||
# define USE_UNNAMED_SEMAPHORE 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Whether to print debugging messages. */
|
||||
#define ENABLE_DEBUGGING 0
|
||||
|
||||
@@ -72,19 +50,13 @@
|
||||
# include <sched.h>
|
||||
#endif
|
||||
|
||||
#if USE_SEMAPHORE
|
||||
# include <errno.h>
|
||||
# include <fcntl.h>
|
||||
# include <semaphore.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_DECL_ALARM
|
||||
# include <signal.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include "macros.h"
|
||||
#include "atomic-int-posix.h"
|
||||
|
||||
#if ENABLE_DEBUGGING
|
||||
# define dbgprintf printf
|
||||
@@ -98,137 +70,6 @@
|
||||
# define yield()
|
||||
#endif
|
||||
|
||||
#if USE_VOLATILE
|
||||
struct atomic_int {
|
||||
volatile int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
return ai->value;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ai->value = new_value;
|
||||
}
|
||||
#elif USE_SEMAPHORE
|
||||
/* This atomic_int implementation can only support the values 0 and 1.
|
||||
It is initially 0 and can be set to 1 only once. */
|
||||
# if USE_UNNAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) (&(ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_init (&ai->semaphore, 0, 0);
|
||||
}
|
||||
# endif
|
||||
# if USE_NAMED_SEMAPHORE
|
||||
struct atomic_int {
|
||||
sem_t *semaphore;
|
||||
};
|
||||
#define atomic_int_semaphore(ai) ((ai)->semaphore)
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
sem_t *s;
|
||||
unsigned int count;
|
||||
for (count = 0; ; count++)
|
||||
{
|
||||
char name[80];
|
||||
/* Use getpid() in the name, so that different processes running at the
|
||||
same time will not interfere. Use ai in the name, so that different
|
||||
atomic_int in the same process will not interfere. Use a count in
|
||||
the name, so that even in the (unlikely) case that a semaphore with
|
||||
the specified name already exists, we can try a different name. */
|
||||
sprintf (name, "test-lock-%lu-%p-%u",
|
||||
(unsigned long) getpid (), ai, count);
|
||||
s = sem_open (name, O_CREAT | O_EXCL, 0600, 0);
|
||||
if (s == SEM_FAILED)
|
||||
{
|
||||
if (errno == EEXIST)
|
||||
/* Retry with a different name. */
|
||||
continue;
|
||||
else
|
||||
{
|
||||
perror ("sem_open failed");
|
||||
abort ();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Try not to leave a semaphore hanging around on the file system
|
||||
eternally, if we can avoid it. */
|
||||
sem_unlink (name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ai->semaphore = s;
|
||||
}
|
||||
# endif
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
if (sem_trywait (atomic_int_semaphore (ai)) == 0)
|
||||
{
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
return 1;
|
||||
}
|
||||
else if (errno == EAGAIN)
|
||||
return 0;
|
||||
else
|
||||
abort ();
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
if (new_value == 0)
|
||||
/* It's already initialized with 0. */
|
||||
return;
|
||||
/* To set the value 1: */
|
||||
if (sem_post (atomic_int_semaphore (ai)))
|
||||
abort ();
|
||||
}
|
||||
#else
|
||||
struct atomic_int {
|
||||
pthread_mutex_t lock;
|
||||
int value;
|
||||
};
|
||||
static void
|
||||
init_atomic_int (struct atomic_int *ai)
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
ASSERT (pthread_mutexattr_init (&attr) == 0);
|
||||
ASSERT (pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL) == 0);
|
||||
ASSERT (pthread_mutex_init (&ai->lock, &attr) == 0);
|
||||
ASSERT (pthread_mutexattr_destroy (&attr) == 0);
|
||||
}
|
||||
static int
|
||||
get_atomic_int_value (struct atomic_int *ai)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
int ret = ai->value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
return ret;
|
||||
}
|
||||
static void
|
||||
set_atomic_int_value (struct atomic_int *ai, int new_value)
|
||||
{
|
||||
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
|
||||
ai->value = new_value;
|
||||
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
|
||||
}
|
||||
#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.
|
||||
|
||||
Reference in New Issue
Block a user