summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/ChangeLog27
-rw-r--r--tests/GNUmakefile24
-rw-r--r--tests/Makefile29
-rw-r--r--tests/README.benchtests163
-rwxr-xr-xtests/SIZES.GC20
-rwxr-xr-xtests/SIZES.GCE20
-rwxr-xr-xtests/SIZES.VC20
-rw-r--r--tests/benchlib.c338
-rw-r--r--tests/benchtest.h295
-rw-r--r--tests/benchtest1.c23
-rw-r--r--tests/benchtest2.c2
-rw-r--r--tests/benchtest5.c20
-rw-r--r--tests/inherit1.c17
-rw-r--r--tests/priority1.c21
-rw-r--r--tests/priority2.c35
-rw-r--r--tests/sizes.c28
16 files changed, 663 insertions, 419 deletions
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 2107c84..667747f 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,9 +1,28 @@
+2003-09-18 Ross Johnson <rpj@callisto.canberra.edu.au>
+
+ * benchtest.h: Move old mutex code into benchlib.c.
+ * benchlib.c: New statically linked module to ensure that
+ bench apps don't inline the code and therefore have an unfair
+ advantage over the pthreads lib routines. Made little or no
+ difference.
+ * benchtest1.c: Minor change to avoid compiler warnings.
+ * benchtest5.c: Likewise.
+ * benchtest2.c: Fix misinformation in output report.
+ * README.BENCH: Add comments on results.
+
+2003-09-14 Ross Johnson <rpj@callisto.canberra.edu.au>
+
+ * priority1.c: Reworked to comply with modified priority
+ management and provide additional output.
+ * priority2.c: Likewise.
+ * inherit1.c: Likewise.
+
2003-09-03 Ross Johnson <rpj@callisto.canberra.edu.au>
- * exit4.c: New test.
- * exit5.c: New test.
- * cancel7.c: New test.
- * cancel8.c: New test.
+ * exit4.c: New test.
+ * exit5.c: New test.
+ * cancel7.c: New test.
+ * cancel8.c: New test.
2003-08-13 Ross Johnson <rpj@ise.canberra.edu.au>
diff --git a/tests/GNUmakefile b/tests/GNUmakefile
index a308227..7ed1c85 100644
--- a/tests/GNUmakefile
+++ b/tests/GNUmakefile
@@ -47,6 +47,7 @@ MAKE = make
# Mingw32
#
XXCFLAGS =
+XXLIBS =
CFLAGS = -O3 -UNDEBUG -Wall $(XXCFLAGS)
#CFLAGS = -g -O0 -UNDEBUG -Wall $(XXCFLAGS)
BUILD_DIR = ..
@@ -62,7 +63,7 @@ COPYFILES = $(HDR) $(LIB) $(DLL)
# If a test case returns a non-zero exit code to the shell, make will
# stop.
-TESTS = loadfree \
+TESTS = sizes loadfree \
semaphore1 semaphore2 self1 mutex5 mutex1 mutex1e mutex1n mutex1r \
condvar1 condvar1_1 condvar1_2 condvar2 condvar2_1 exit1 \
create1 create2 reuse1 reuse2 equal1 \
@@ -115,10 +116,10 @@ GCX:
$(MAKE) GCX=GC CC=g++ XXCFLAGS="-mthreads -D__CLEANUP_C" all-pass
GC-bench:
- $(MAKE) GCX=GC CC=gcc XXCFLAGS="-D__CLEANUP_C" all-bench
+ $(MAKE) GCX=GC CC=gcc XXCFLAGS="-D__CLEANUP_C" XXLIBS="benchlib.o" all-bench
GCE-bench:
- $(MAKE) GCX=GCE CC=g++ XXCFLAGS="-mthreads -D__CLEANUP_CXX" all-bench
+ $(MAKE) GCX=GCE CC=g++ XXCFLAGS="-mthreads -D__CLEANUP_CXX" XXLIBS="benchlib." all-bench
all-pass: $(PASSES)
@ $(ECHO) ALL TESTS PASSED! Congratulations!
@@ -183,7 +184,7 @@ exit3.pass: create1.pass
exit4.pass:
exit5.pass: exit4.pass kill1.pass
eyal1.pass: tsd1.pass
-inherit1.pass: join1.pass
+inherit1.pass: join1.pass priority1.pass
join0.pass: create1.pass
join1.pass: create1.pass
join2.pass: create1.pass
@@ -211,7 +212,7 @@ mutex8e.pass: mutex7e.pass
mutex8r.pass: mutex7r.pass
once1.pass: create1.pass
priority1.pass: join1.pass
-priority2.pass: priority1.pass
+priority2.pass: priority1.pass barrier3.pass
reuse1.pass: create2.pass
reuse2.pass: reuse1.pass
rwlock1.pass: condvar6.pass
@@ -231,6 +232,7 @@ self1.pass:
self2.pass: create1.pass
semaphore1.pass:
semaphore2.pass:
+sizes.pass:
spin1.pass:
spin2.pass: spin1.pass
spin3.pass: spin2.pass
@@ -246,7 +248,7 @@ valid2.pass: valid1.pass
@ $(ECHO) Passed
@ $(TOUCH) $@
-%.bench: %.exe $(LIB) $(DLL) $(HDR)
+%.bench: $(LIB) $(DLL) $(HDR) $(XXLIBS) %.exe
@ $(ECHO) Running $*
$*
@ $(ECHO) Done
@@ -254,8 +256,8 @@ valid2.pass: valid1.pass
%.exe: %.c
@ $(ECHO) Compiling $@
- @ $(ECHO) $(CC) $(CFLAGS) -o $@ $^ $(INCLUDES) -L. -lpthread$(GCX)
- @ $(CC) $(CFLAGS) -o $@ $^ $(INCLUDES) -L. -lpthread$(GCX) -lsupc++
+ @ $(ECHO) $(CC) $(CFLAGS) -o $@ $^ $(INCLUDES) -L. -lpthread$(GCX) -lsupc++ $(XXLIBS)
+ @ $(CC) $(CFLAGS) -o $@ $^ $(INCLUDES) -L. -lpthread$(GCX) -lsupc++ $(XXLIBS)
%.pre: %.c
@ $(CC) -E $(CFLAGS) -o $@ $^ $(INCLUDES)
@@ -270,6 +272,11 @@ $(COPYFILES):
pthread.dll:
@ $(CP) $(DLL) $@
+benchlib.o: benchlib.c
+ @ $(ECHO) Compiling $@
+ @ $(ECHO) $(CC) -c $(CFLAGS) $^ $(INCLUDES)
+ @ $(CC) -c $(CFLAGS) $^ $(INCLUDES)
+
clean:
- $(RM) *.dll
- $(RM) *.lib
@@ -279,6 +286,7 @@ clean:
- $(RM) *.a
- $(RM) *.e
- $(RM) *.i
+ - $(RM) *.o
- $(RM) *.obj
- $(RM) *.pdb
- $(RM) *.exe
diff --git a/tests/Makefile b/tests/Makefile
index 94c593f..210b8a1 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -42,6 +42,8 @@ CPHDR = pthread.h semaphore.h sched.h
OPTIM = /O2 /Ob0
+XXLIBS =
+
# C++ Exceptions
VCEFLAGS = /GX /TP /DPtW32NoCatchWarn /D__CLEANUP_CXX
VCELIB = pthreadVCE.lib
@@ -70,7 +72,7 @@ EHFLAGS =
# If a test case returns a non-zero exit code to the shell, make will
# stop.
-PASSES= loadfree.pass \
+PASSES= sizes.pass loadfree.pass \
semaphore1.pass semaphore2.pass self1.pass mutex5.pass \
mutex1.pass mutex1n.pass mutex1e.pass mutex1r.pass mutex2.pass mutex3.pass \
condvar1.pass condvar1_1.pass condvar1_2.pass condvar2.pass condvar2_1.pass \
@@ -93,7 +95,7 @@ PASSES= loadfree.pass \
rwlock2_t.pass rwlock3_t.pass rwlock4_t.pass rwlock5_t.pass rwlock6_t.pass rwlock6_t2.pass \
context1.pass \
cancel3.pass cancel4.pass cancel5.pass cancel6a.pass cancel6d.pass \
- cancel7 cancel8 \
+ cancel7 cancel8 \
cleanup0.pass cleanup1.pass cleanup2.pass cleanup3.pass \
priority1.pass priority2.pass inherit1.pass \
spin1.pass spin2.pass spin3.pass spin4.pass \
@@ -124,7 +126,7 @@ all:
tests: $(CPLIB) $(CPDLL) $(CPHDR) $(PASSES)
@ $(ECHO) ALL TESTS PASSED! Congratulations!
-benchtests: $(CPLIB) $(CPDLL) $(CPHDR) $(BENCHRESULTS)
+benchtests: $(CPLIB) $(CPDLL) $(CPHDR) $(XXLIBS) $(BENCHRESULTS)
@ $(ECHO) ALL BENCH TESTS DONE.
$(PASSES): $*.exe
@@ -152,20 +154,24 @@ VCX:
@ nmake TEST="$@" CPLIB="$(VCLIB)" CPDLL="$(VCDLL)" EHFLAGS="$(VCXFLAGS)" tests
VCE-bench:
- @ nmake TEST="$@" CPLIB="$(VCELIB)" CPDLL="$(VCEDLL)" EHFLAGS="$(VCEFLAGS)" benchtests
+ @ nmake TEST="$@" CPLIB="$(VCELIB)" CPDLL="$(VCEDLL)" EHFLAGS="$(VCEFLAGS)" XXLIBS="benchlib.o" benchtests
VSE-bench:
- @ nmake TEST="$@" CPLIB="$(VSELIB)" CPDLL="$(VSEDLL)" EHFLAGS="$(VSEFLAGS)" benchtests
+ @ nmake TEST="$@" CPLIB="$(VSELIB)" CPDLL="$(VSEDLL)" EHFLAGS="$(VSEFLAGS)" XXLIBS="benchlib.o" benchtests
VC-bench:
- @ nmake TEST="$@" CPLIB="$(VCLIB)" CPDLL="$(VCDLL)" EHFLAGS="$(VCFLAGS)" benchtests
+ @ nmake TEST="$@" CPLIB="$(VCLIB)" CPDLL="$(VCDLL)" EHFLAGS="$(VCFLAGS)" XXLIBS="benchlib.o" benchtests
VCX-bench:
- @ nmake TEST="$@" CPLIB="$(VCLIB)" CPDLL="$(VCDLL)" EHFLAGS="$(VCXFLAGS)" benchtests
+ @ nmake TEST="$@" CPLIB="$(VCLIB)" CPDLL="$(VCDLL)" EHFLAGS="$(VCXFLAGS)" XXLIBS="benchlib.o" benchtests
.c.exe:
- @ $(ECHO) $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< /Fe$@ /link $(LFLAGS) $(CPLIB)
- @ $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< /Fe$@ /link $(LFLAGS) $(CPLIB)
+ @ $(ECHO) $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< /Fe$@ /link $(LFLAGS) $(CPLIB) $(XXLIBS)
+ @ $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< /Fe$@ /link $(LFLAGS) $(CPLIB) $(XXLIBS)
+
+.c.o:
+ @ $(ECHO) $(CC) $(EHFLAGS) /c $(CFLAGS) $(INCLUDES) $< /Fo$@
+ @ $(CC) $(EHFLAGS) $(CFLAGS) /c $(INCLUDES) $< /Fo$@
.c.i:
@ $(CC) /P $(EHFLAGS) $(CFLAGS) $(INCLUDES) $<
@@ -250,7 +256,7 @@ exit3.pass: create1.pass
exit4.pass:
exit5.pass: kill1.pass
eyal1.pass: tsd1.pass
-inherit1.pass: join1.pass
+inherit1.pass: join1.pass priority1.pass
join0.pass: create1.pass
join1.pass: create1.pass
join2.pass: create1.pass
@@ -278,7 +284,7 @@ mutex8e.pass: mutex7e.pass
mutex8r.pass: mutex7r.pass
once1.pass: create1.pass
priority1.pass: join1.pass
-priority2.pass: priority1.pass
+priority2.pass: priority1.pass barrier3.pass
reuse1.pass: create2.pass
reuse2.pass: reuse1.pass
rwlock1.pass: condvar6.pass
@@ -298,6 +304,7 @@ self1.pass:
self2.pass: create1.pass
semaphore1.pass:
semaphore2.pass:
+sizes.pass:
spin1.pass:
spin2.pass: spin1.pass
spin3.pass: spin2.pass
diff --git a/tests/README.benchtests b/tests/README.benchtests
index 1d8e1e3..01051a2 100644
--- a/tests/README.benchtests
+++ b/tests/README.benchtests
@@ -1,66 +1,97 @@
-
-------------
-Benchmarking
-------------
-There is a new but growing set a benchmarking programs in the
-"tests" directory. These should be runnable using the
-following command-lines corresponding to each of the possible
-library builds:
-
-MSVC:
-nmake clean VC-bench
-nmake clean VCE-bench
-nmake clean VSE-bench
-
-Mingw32:
-make clean GC-bench
-make clean GCE-bench
-
-UWIN:
-The benchtests are run as part of the testsuite.
-
-
-Mutex benchtests
-----------------
-
-benchtest1 - Lock plus unlock on an unlocked mutex.
-benchtest2 - Lock plus unlock on a locked mutex.
-benchtest3 - Trylock on a locked mutex.
-benchtest4 - Trylock plus unlock on an unlocked mutex.
-
-
-Each test times up to three alternate synchronisation
-implementations as a reference, and then times each of
-the four mutex types provided by the library. Each is
-described below:
-
-Simple Critical Section
-- uses a simple Win32 critical section. There is no
-additional overhead for this case as there is in the
-remaining cases.
-
-POSIX mutex implemented using a Critical Section
-- The old implementation which uses runtime adaptation
-depending on the Windows variant being run on. When
-the pthreads DLL was run on WinNT or higher then
-POSIX mutexes would use Win32 Critical Sections.
-
-POSIX mutex implemented using a Win32 Mutex
-- The old implementation which uses runtime adaptation
-depending on the Windows variant being run on. When
-the pthreads DLL was run on Win9x then POSIX mutexes
-would use Win32 Mutexes (because TryEnterCriticalSection
-is not implemented on Win9x).
-
-PTHREAD_MUTEX_DEFAULT
-PTHREAD_MUTEX_NORMAL
-PTHREAD_MUTEX_ERRORCHECK
-PTHREAD_MUTEX_RECURSIVE
-- The current implementation supports these mutex types.
-The underlying basis of POSIX mutexes is now the same
-irrespective of the Windows variant.
-
-
-In all benchtests, the operation is repeated a large
-number of times and an average is calculated. Loop
-overhead is measured and subtracted from all test times.
+
+------------
+Benchmarking
+------------
+There is a new but growing set a benchmarking programs in the
+"tests" directory. These should be runnable using the
+following command-lines corresponding to each of the possible
+library builds:
+
+MSVC:
+nmake clean VC-bench
+nmake clean VCE-bench
+nmake clean VSE-bench
+
+Mingw32:
+make clean GC-bench
+make clean GCE-bench
+
+UWIN:
+The benchtests are run as part of the testsuite.
+
+
+Mutex benchtests
+----------------
+
+benchtest1 - Lock plus unlock on an unlocked mutex.
+benchtest2 - Lock plus unlock on a locked mutex.
+benchtest3 - Trylock on a locked mutex.
+benchtest4 - Trylock plus unlock on an unlocked mutex.
+
+
+Each test times up to three alternate synchronisation
+implementations as a reference, and then times each of
+the four mutex types provided by the library. Each is
+described below:
+
+Simple Critical Section
+- uses a simple Win32 critical section. There is no
+additional overhead for this case as there is in the
+remaining cases.
+
+POSIX mutex implemented using a Critical Section
+- The old implementation which uses runtime adaptation
+depending on the Windows variant being run on. When
+the pthreads DLL was run on WinNT or higher then
+POSIX mutexes would use Win32 Critical Sections.
+
+POSIX mutex implemented using a Win32 Mutex
+- The old implementation which uses runtime adaptation
+depending on the Windows variant being run on. When
+the pthreads DLL was run on Win9x then POSIX mutexes
+would use Win32 Mutexes (because TryEnterCriticalSection
+is not implemented on Win9x).
+
+PTHREAD_MUTEX_DEFAULT
+PTHREAD_MUTEX_NORMAL
+PTHREAD_MUTEX_ERRORCHECK
+PTHREAD_MUTEX_RECURSIVE
+- The current implementation supports these mutex types.
+The underlying basis of POSIX mutexes is now the same
+irrespective of the Windows variant, and should therefore
+have consistent performance.
+
+
+In all benchtests, the operation is repeated a large
+number of times and an average is calculated. Loop
+overhead is measured and subtracted from all test times.
+
+Comment on the results
+----------------------
+The gain in performance for Win9x systems is enormous - up to
+40 times faster for unlocked mutexes (2 times faster for locked
+mutexes).
+
+Pthread_mutex_trylock also appears to be faster for locked mutexes.
+
+The price for the new consistency between WinNT and Win9x is
+slower performance (up to twice as long) across a lock/unlock
+sequence. It is difficult to get a good split timing for lock
+and unlock operations, but by code inspection, it is the unlock
+operation that is slowing the pair down in comparison with the
+old-style CS mutexes, even for the fast PTHREAD_MUTEX_NORMAL mutex
+type with no other waiting threads. However, comparitive
+performance for operations on already locked mutexes is very close.
+
+When this is translated to real-world applications, the overall
+camparitive performance should be almost identical on NT class
+systems. That is, applications with heavy mutex contention should
+have almost equal performance, while applications with only light
+mutex contention should also have almost equal performance because
+the most critical operation in this case is the lock operation.
+
+Overall, the newer pthreads-win32 mutex routines are only slower
+(on NT class systems) where and when it is least critical.
+
+Thanks go to Thomas Pfaff for the current implementation of mutex
+routines.
diff --git a/tests/SIZES.GC b/tests/SIZES.GC
new file mode 100755
index 0000000..ae09a84
--- /dev/null
+++ b/tests/SIZES.GC
@@ -0,0 +1,20 @@
+Sizes of pthreads-win32 structs
+-------------------------------
+ pthread_t_ 124
+ pthread_attr_t_ 28
+ sem_t_ 4
+ pthread_mutex_t_ 44
+ pthread_mutexattr_t_ 8
+ pthread_spinlock_t_ 8
+ pthread_barrier_t_ 24
+ pthread_barrierattr_t_ 4
+ pthread_key_t_ 16
+ pthread_cond_t_ 32
+ pthread_condattr_t_ 4
+ pthread_rwlock_t_ 28
+ pthread_rwlockattr_t_ 4
+ pthread_once_t_ 8
+ ptw32_cleanup_t 12
+ sched_param 4
+-------------------------------
+
diff --git a/tests/SIZES.GCE b/tests/SIZES.GCE
new file mode 100755
index 0000000..f36d0d2
--- /dev/null
+++ b/tests/SIZES.GCE
@@ -0,0 +1,20 @@
+Sizes of pthreads-win32 structs
+-------------------------------
+ pthread_t_ 60
+ pthread_attr_t_ 28
+ sem_t_ 4
+ pthread_mutex_t_ 44
+ pthread_mutexattr_t_ 8
+ pthread_spinlock_t_ 8
+ pthread_barrier_t_ 24
+ pthread_barrierattr_t_ 4
+ pthread_key_t_ 16
+ pthread_cond_t_ 32
+ pthread_condattr_t_ 4
+ pthread_rwlock_t_ 28
+ pthread_rwlockattr_t_ 4
+ pthread_once_t_ 8
+ ptw32_cleanup_t 12
+ sched_param 4
+-------------------------------
+
diff --git a/tests/SIZES.VC b/tests/SIZES.VC
new file mode 100755
index 0000000..ae09a84
--- /dev/null
+++ b/tests/SIZES.VC
@@ -0,0 +1,20 @@
+Sizes of pthreads-win32 structs
+-------------------------------
+ pthread_t_ 124
+ pthread_attr_t_ 28
+ sem_t_ 4
+ pthread_mutex_t_ 44
+ pthread_mutexattr_t_ 8
+ pthread_spinlock_t_ 8
+ pthread_barrier_t_ 24
+ pthread_barrierattr_t_ 4
+ pthread_key_t_ 16
+ pthread_cond_t_ 32
+ pthread_condattr_t_ 4
+ pthread_rwlock_t_ 28
+ pthread_rwlockattr_t_ 4
+ pthread_once_t_ 8
+ ptw32_cleanup_t 12
+ sched_param 4
+-------------------------------
+
diff --git a/tests/benchlib.c b/tests/benchlib.c
new file mode 100644
index 0000000..78ec3c8
--- /dev/null
+++ b/tests/benchlib.c
@@ -0,0 +1,338 @@
+/*
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Pthreads-win32 - POSIX Threads Library for Win32
+ * Copyright(C) 1998 John E. Bossom
+ * Copyright(C) 1999,2003 Pthreads-win32 contributors
+ *
+ * Contact Email: rpj@callisto.canberra.edu.au
+ *
+ * The current list of contributors is contained
+ * in the file CONTRIBUTORS included with the source
+ * code distribution. The list can also be seen at the
+ * following World Wide Web location:
+ * http://sources.redhat.com/pthreads-win32/contributors.html
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library in the file COPYING.LIB;
+ * if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ *
+ */
+
+#include "../config.h"
+
+#include "pthread.h"
+#include "sched.h"
+#include "semaphore.h"
+#include <windows.h>
+#include <stdio.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+int old_mutex_use = OLD_WIN32CS;
+
+BOOL (WINAPI *ptw32_try_enter_critical_section)(LPCRITICAL_SECTION) = NULL;
+HINSTANCE ptw32_h_kernel32;
+
+int
+old_mutex_init(old_mutex_t *mutex, const old_mutexattr_t *attr)
+{
+ int result = 0;
+ old_mutex_t mx;
+
+ if (mutex == NULL)
+ {
+ return EINVAL;
+ }
+
+ mx = (old_mutex_t) calloc(1, sizeof(*mx));
+
+ if (mx == NULL)
+ {
+ result = ENOMEM;
+ goto FAIL0;
+ }
+
+ mx->mutex = 0;
+
+ if (attr != NULL
+ && *attr != NULL
+ && (*attr)->pshared == PTHREAD_PROCESS_SHARED
+ )
+ {
+ result = ENOSYS;
+ }
+ else
+ {
+ CRITICAL_SECTION cs;
+
+ /*
+ * Load KERNEL32 and try to get address of TryEnterCriticalSection
+ */
+ ptw32_h_kernel32 = LoadLibrary(TEXT("KERNEL32.DLL"));
+ ptw32_try_enter_critical_section = (BOOL (WINAPI *)(LPCRITICAL_SECTION))
+
+#if defined(NEED_UNICODE_CONSTS)
+ GetProcAddress(ptw32_h_kernel32,
+ (const TCHAR *)TEXT("TryEnterCriticalSection"));
+#else
+ GetProcAddress(ptw32_h_kernel32,
+ (LPCSTR) "TryEnterCriticalSection");
+#endif
+
+ if (ptw32_try_enter_critical_section != NULL)
+ {
+ InitializeCriticalSection(&cs);
+ if ((*ptw32_try_enter_critical_section)(&cs))
+ {
+ LeaveCriticalSection(&cs);
+ }
+ else
+ {
+ /*
+ * Not really supported (Win98?).
+ */
+ ptw32_try_enter_critical_section = NULL;
+ }
+ DeleteCriticalSection(&cs);
+ }
+
+ if (ptw32_try_enter_critical_section == NULL)
+ {
+ (void) FreeLibrary(ptw32_h_kernel32);
+ ptw32_h_kernel32 = 0;
+ }
+
+ if (old_mutex_use == OLD_WIN32CS)
+ {
+ InitializeCriticalSection(&mx->cs);
+ }
+ else if (old_mutex_use == OLD_WIN32MUTEX)
+ {
+ mx->mutex = CreateMutex (NULL,
+ FALSE,
+ NULL);
+
+ if (mx->mutex == 0)
+ {
+ result = EAGAIN;
+ }
+ }
+ else
+ {
+ result = EINVAL;
+ }
+ }
+
+ if (result != 0 && mx != NULL)
+ {
+ free(mx);
+ mx = NULL;
+ }
+
+FAIL0:
+ *mutex = mx;
+
+ return(result);
+}
+
+
+int
+old_mutex_lock(old_mutex_t *mutex)
+{
+ int result = 0;
+ old_mutex_t mx;
+
+ if (mutex == NULL || *mutex == NULL)
+ {
+ return EINVAL;
+ }
+
+ if (*mutex == (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
+ {
+ /*
+ * Don't use initialisers when benchtesting.
+ */
+ result = EINVAL;
+ }
+
+ mx = *mutex;
+
+ if (result == 0)
+ {
+ if (mx->mutex == 0)
+ {
+ EnterCriticalSection(&mx->cs);
+ }
+ else
+ {
+ result = (WaitForSingleObject(mx->mutex, INFINITE)
+ == WAIT_OBJECT_0)
+ ? 0
+ : EINVAL;
+ }
+ }
+
+ return(result);
+}
+
+int
+old_mutex_unlock(old_mutex_t *mutex)
+{
+ int result = 0;
+ old_mutex_t mx;
+
+ if (mutex == NULL || *mutex == NULL)
+ {
+ return EINVAL;
+ }
+
+ mx = *mutex;
+
+ if (mx != (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
+ {
+ if (mx->mutex == 0)
+ {
+ LeaveCriticalSection(&mx->cs);
+ }
+ else
+ {
+ result = (ReleaseMutex (mx->mutex) ? 0 : EINVAL);
+ }
+ }
+ else
+ {
+ result = EINVAL;
+ }
+
+ return(result);
+}
+
+
+int
+old_mutex_trylock(old_mutex_t *mutex)
+{
+ int result = 0;
+ old_mutex_t mx;
+
+ if (mutex == NULL || *mutex == NULL)
+ {
+ return EINVAL;
+ }
+
+ if (*mutex == (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
+ {
+ /*
+ * Don't use initialisers when benchtesting.
+ */
+ result = EINVAL;
+ }
+
+ mx = *mutex;
+
+ if (result == 0)
+ {
+ if (mx->mutex == 0)
+ {
+ if (ptw32_try_enter_critical_section == NULL)
+ {
+ result = 0;
+ }
+ else if ((*ptw32_try_enter_critical_section)(&mx->cs) != TRUE)
+ {
+ result = EBUSY;
+ }
+ }
+ else
+ {
+ DWORD status;
+
+ status = WaitForSingleObject (mx->mutex, 0);
+
+ if (status != WAIT_OBJECT_0)
+ {
+ result = ((status == WAIT_TIMEOUT)
+ ? EBUSY
+ : EINVAL);
+ }
+ }
+ }
+
+ return(result);
+}
+
+
+int
+old_mutex_destroy(old_mutex_t *mutex)
+{
+ int result = 0;
+ old_mutex_t mx;
+
+ if (mutex == NULL
+ || *mutex == NULL)
+ {
+ return EINVAL;
+ }
+
+ if (*mutex != (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
+ {
+ mx = *mutex;
+
+ if ((result = old_mutex_trylock(&mx)) == 0)
+ {
+ *mutex = NULL;
+
+ (void) old_mutex_unlock(&mx);
+
+ if (mx->mutex == 0)
+ {
+ DeleteCriticalSection(&mx->cs);
+ }
+ else
+ {
+ result = (CloseHandle (mx->mutex) ? 0 : EINVAL);
+ }
+
+ if (result == 0)
+ {
+ mx->mutex = 0;
+ free(mx);
+ }
+ else
+ {
+ *mutex = mx;
+ }
+ }
+ }
+ else
+ {
+ result = EINVAL;
+ }
+
+ if (ptw32_try_enter_critical_section != NULL)
+ {
+ (void) FreeLibrary(ptw32_h_kernel32);
+ ptw32_h_kernel32 = 0;
+ }
+
+ return(result);
+}
+
+/****************************************************************************************/
diff --git a/tests/benchtest.h b/tests/benchtest.h
index c04e62e..2401622 100644
--- a/tests/benchtest.h
+++ b/tests/benchtest.h
@@ -39,7 +39,7 @@ enum {
OLD_WIN32MUTEX
};
-static int old_mutex_use = OLD_WIN32CS;
+extern int old_mutex_use;
struct old_mutex_t_ {
HANDLE mutex;
@@ -54,293 +54,14 @@ struct old_mutexattr_t_ {
typedef struct old_mutexattr_t_ * old_mutexattr_t;
-static BOOL (WINAPI *ptw32_try_enter_critical_section)(LPCRITICAL_SECTION) = NULL;
-static HINSTANCE ptw32_h_kernel32;
+extern BOOL (WINAPI *ptw32_try_enter_critical_section)(LPCRITICAL_SECTION);
+extern HINSTANCE ptw32_h_kernel32;
#define PTW32_OBJECT_AUTO_INIT ((void *) -1)
-static int
-old_mutex_init(old_mutex_t *mutex, const old_mutexattr_t *attr)
-{
- int result = 0;
- old_mutex_t mx;
-
- if (mutex == NULL)
- {
- return EINVAL;
- }
-
- mx = (old_mutex_t) calloc(1, sizeof(*mx));
-
- if (mx == NULL)
- {
- result = ENOMEM;
- goto FAIL0;
- }
-
- mx->mutex = 0;
-
- if (attr != NULL
- && *attr != NULL
- && (*attr)->pshared == PTHREAD_PROCESS_SHARED
- )
- {
- result = ENOSYS;
- }
- else
- {
- CRITICAL_SECTION cs;
-
- /*
- * Load KERNEL32 and try to get address of TryEnterCriticalSection
- */
- ptw32_h_kernel32 = LoadLibrary(TEXT("KERNEL32.DLL"));
- ptw32_try_enter_critical_section = (BOOL (WINAPI *)(LPCRITICAL_SECTION))
-
-#if defined(NEED_UNICODE_CONSTS)
- GetProcAddress(ptw32_h_kernel32,
- (const TCHAR *)TEXT("TryEnterCriticalSection"));
-#else
- GetProcAddress(ptw32_h_kernel32,
- (LPCSTR) "TryEnterCriticalSection");
-#endif
-
- if (ptw32_try_enter_critical_section != NULL)
- {
- InitializeCriticalSection(&cs);
- if ((*ptw32_try_enter_critical_section)(&cs))
- {
- LeaveCriticalSection(&cs);
- }
- else
- {
- /*
- * Not really supported (Win98?).
- */
- ptw32_try_enter_critical_section = NULL;
- }
- DeleteCriticalSection(&cs);
- }
-
- if (ptw32_try_enter_critical_section == NULL)
- {
- (void) FreeLibrary(ptw32_h_kernel32);
- ptw32_h_kernel32 = 0;
- }
-
- if (old_mutex_use == OLD_WIN32CS)
- {
- InitializeCriticalSection(&mx->cs);
- }
- else if (old_mutex_use == OLD_WIN32MUTEX)
- {
- mx->mutex = CreateMutex (NULL,
- FALSE,
- NULL);
-
- if (mx->mutex == 0)
- {
- result = EAGAIN;
- }
- }
- else
- {
- result = EINVAL;
- }
- }
-
- if (result != 0 && mx != NULL)
- {
- free(mx);
- mx = NULL;
- }
-
-FAIL0:
- *mutex = mx;
-
- return(result);
-}
-
-
-static int
-old_mutex_lock(old_mutex_t *mutex)
-{
- int result = 0;
- old_mutex_t mx;
-
- if (mutex == NULL || *mutex == NULL)
- {
- return EINVAL;
- }
-
- if (*mutex == (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
- {
- /*
- * Don't use initialisers when benchtesting.
- */
- result = EINVAL;
- }
-
- mx = *mutex;
-
- if (result == 0)
- {
- if (mx->mutex == 0)
- {
- EnterCriticalSection(&mx->cs);
- }
- else
- {
- result = (WaitForSingleObject(mx->mutex, INFINITE)
- == WAIT_OBJECT_0)
- ? 0
- : EINVAL;
- }
- }
-
- return(result);
-}
-
-static int
-old_mutex_unlock(old_mutex_t *mutex)
-{
- int result = 0;
- old_mutex_t mx;
-
- if (mutex == NULL || *mutex == NULL)
- {
- return EINVAL;
- }
-
- mx = *mutex;
-
- if (mx != (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
- {
- if (mx->mutex == 0)
- {
- LeaveCriticalSection(&mx->cs);
- }
- else
- {
- result = (ReleaseMutex (mx->mutex) ? 0 : EINVAL);
- }
- }
- else
- {
- result = EINVAL;
- }
-
- return(result);
-}
-
-
-static int
-old_mutex_trylock(old_mutex_t *mutex)
-{
- int result = 0;
- old_mutex_t mx;
-
- if (mutex == NULL || *mutex == NULL)
- {
- return EINVAL;
- }
-
- if (*mutex == (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
- {
- /*
- * Don't use initialisers when benchtesting.
- */
- result = EINVAL;
- }
-
- mx = *mutex;
-
- if (result == 0)
- {
- if (mx->mutex == 0)
- {
- if (ptw32_try_enter_critical_section == NULL)
- {
- result = 0;
- }
- else if ((*ptw32_try_enter_critical_section)(&mx->cs) != TRUE)
- {
- result = EBUSY;
- }
- }
- else
- {
- DWORD status;
-
- status = WaitForSingleObject (mx->mutex, 0);
-
- if (status != WAIT_OBJECT_0)
- {
- result = ((status == WAIT_TIMEOUT)
- ? EBUSY
- : EINVAL);
- }
- }
- }
-
- return(result);
-}
-
-
-static int
-old_mutex_destroy(old_mutex_t *mutex)
-{
- int result = 0;
- old_mutex_t mx;
-
- if (mutex == NULL
- || *mutex == NULL)
- {
- return EINVAL;
- }
-
- if (*mutex != (old_mutex_t) PTW32_OBJECT_AUTO_INIT)
- {
- mx = *mutex;
-
- if ((result = old_mutex_trylock(&mx)) == 0)
- {
- *mutex = NULL;
-
- (void) old_mutex_unlock(&mx);
-
- if (mx->mutex == 0)
- {
- DeleteCriticalSection(&mx->cs);
- }
- else
- {
- result = (CloseHandle (mx->mutex) ? 0 : EINVAL);
- }
-
- if (result == 0)
- {
- mx->mutex = 0;
- free(mx);
- }
- else
- {
- *mutex = mx;
- }
- }
- }
- else
- {
- result = EINVAL;
- }
-
- if (ptw32_try_enter_critical_section != NULL)
- {
- (void) FreeLibrary(ptw32_h_kernel32);
- ptw32_h_kernel32 = 0;
- }
-
- return(result);
-}
-
+int old_mutex_init(old_mutex_t *mutex, const old_mutexattr_t *attr);
+int old_mutex_lock(old_mutex_t *mutex);
+int old_mutex_unlock(old_mutex_t *mutex);
+int old_mutex_trylock(old_mutex_t *mutex);
+int old_mutex_destroy(old_mutex_t *mutex);
/****************************************************************************************/
diff --git a/tests/benchtest1.c b/tests/benchtest1.c
index ed127ba..1a553dc 100644
--- a/tests/benchtest1.c
+++ b/tests/benchtest1.c
@@ -57,6 +57,8 @@ struct _timeb currSysTimeStart;
struct _timeb currSysTimeStop;
long durationMilliSecs;
long overHeadMilliSecs = 0;
+int one = 1;
+int zero = 0;
#define GetDurationMilliSecs(_TStart, _TStop) ((_TStop.time*1000+_TStop.millitm) \
- (_TStart.time*1000+_TStart.millitm))
@@ -81,8 +83,8 @@ runTest (char * testNameString, int mType)
assert(pthread_mutex_init(&mx, &ma) == 0);
TESTSTART
- assert(pthread_mutex_lock(&mx) == 0);
- assert(pthread_mutex_unlock(&mx) == 0);
+ assert(pthread_mutex_lock(&mx) == zero);
+ assert(pthread_mutex_unlock(&mx) == zero);
TESTSTOP
assert(pthread_mutex_destroy(&mx) == 0);
@@ -101,7 +103,6 @@ main (int argc, char *argv[])
{
CRITICAL_SECTION cs;
old_mutex_t ox;
-
pthread_mutexattr_init(&ma);
printf( "=============================================================================\n");
@@ -118,8 +119,8 @@ main (int argc, char *argv[])
*/
TESTSTART
- assert(1 == 1);
- assert(1 == 1);
+ assert(1 == one);
+ assert(1 == one);
TESTSTOP
durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
@@ -129,8 +130,8 @@ main (int argc, char *argv[])
InitializeCriticalSection(&cs);
TESTSTART
- assert((EnterCriticalSection(&cs), 1) == 1);
- assert((LeaveCriticalSection(&cs), 1) == 1);
+ assert((EnterCriticalSection(&cs), 1) == one);
+ assert((LeaveCriticalSection(&cs), 1) == one);
TESTSTOP
DeleteCriticalSection(&cs);
@@ -147,8 +148,8 @@ main (int argc, char *argv[])
assert(old_mutex_init(&ox, NULL) == 0);
TESTSTART
- assert(old_mutex_lock(&ox) == 0);
- assert(old_mutex_unlock(&ox) == 0);
+ assert(old_mutex_lock(&ox) == zero);
+ assert(old_mutex_unlock(&ox) == zero);
TESTSTOP
assert(old_mutex_destroy(&ox) == 0);
@@ -165,8 +166,8 @@ main (int argc, char *argv[])
assert(old_mutex_init(&ox, NULL) == 0);
TESTSTART
- assert(old_mutex_lock(&ox) == 0);
- assert(old_mutex_unlock(&ox) == 0);
+ assert(old_mutex_lock(&ox) == zero);
+ assert(old_mutex_unlock(&ox) == zero);
TESTSTOP
assert(old_mutex_destroy(&ox) == 0);
diff --git a/tests/benchtest2.c b/tests/benchtest2.c
index b0ac7e4..7caf7c5 100644
--- a/tests/benchtest2.c
+++ b/tests/benchtest2.c
@@ -179,7 +179,7 @@ main (int argc, char *argv[])
assert(pthread_mutexattr_init(&ma) == 0);
printf( "=============================================================================\n");
- printf( "\nLock plus unlock on an unlocked mutex.\n");
+ printf( "\nLock plus unlock on a locked mutex.\n");
printf("%ld iterations, four locks/unlocks per iteration.\n\n", ITERATIONS);
printf( "%-45s %15s %15s\n",
diff --git a/tests/benchtest5.c b/tests/benchtest5.c
index 11ad444..122fcb4 100644
--- a/tests/benchtest5.c
+++ b/tests/benchtest5.c
@@ -56,6 +56,8 @@ struct _timeb currSysTimeStart;
struct _timeb currSysTimeStop;
long durationMilliSecs;
long overHeadMilliSecs = 0;
+int one = 1;
+int zero = 0;
#define GetDurationMilliSecs(_TStart, _TStop) ((_TStop.time*1000+_TStop.millitm) \
- (_TStart.time*1000+_TStart.millitm))
@@ -100,7 +102,7 @@ main (int argc, char *argv[])
*/
TESTSTART
- assert(1 == 1);
+ assert(1 == one);
TESTSTOP
durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
@@ -112,7 +114,7 @@ main (int argc, char *argv[])
*/
assert(sem_init(&sema, 0, 0) == 0);
TESTSTART
- assert(sem_post(&sema) == 0);
+ assert(sem_post(&sema) == zero);
TESTSTOP
assert(sem_destroy(&sema) == 0);
@@ -121,7 +123,7 @@ main (int argc, char *argv[])
assert(sem_init(&sema, 0, ITERATIONS) == 0);
TESTSTART
- assert(sem_wait(&sema) == 0);
+ assert(sem_wait(&sema) == zero);
TESTSTOP
assert(sem_destroy(&sema) == 0);
@@ -133,8 +135,8 @@ main (int argc, char *argv[])
*/
TESTSTART
- assert(1 == 1);
- assert(1 == 1);
+ assert(1 == one);
+ assert(1 == one);
TESTSTOP
durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
@@ -146,8 +148,8 @@ main (int argc, char *argv[])
*/
assert(sem_init(&sema, 0, 0) == 0);
TESTSTART
- assert(sem_post(&sema) == 0);
- assert(sem_wait(&sema) == 0);
+ assert(sem_post(&sema) == zero);
+ assert(sem_wait(&sema) == zero);
TESTSTOP
assert(sem_destroy(&sema) == 0);
@@ -156,8 +158,8 @@ main (int argc, char *argv[])
assert(sem_init(&sema, 0, 1) == 0);
TESTSTART
- assert(sem_wait(&sema) == 0);
- assert(sem_post(&sema) == 0);
+ assert(sem_wait(&sema) == zero);
+ assert(sem_post(&sema) == zero);
TESTSTOP
assert(sem_destroy(&sema) == 0);
diff --git a/tests/inherit1.c b/tests/inherit1.c
index 364aa74..288919c 100644
--- a/tests/inherit1.c
+++ b/tests/inherit1.c
@@ -97,21 +97,22 @@ void *
getValidPriorities(void * arg)
{
int prioSet;
- pthread_t threadID = pthread_self();
- HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+ pthread_t thread = pthread_self();
+ HANDLE threadH = pthread_getw32threadhandle_np(thread);
+ struct sched_param param;
for (prioSet = minPrio;
prioSet <= maxPrio;
prioSet++)
{
- /*
+ /*
* If prioSet is invalid then the threads priority is unchanged
* from the previous value. Make the previous value a known
* one so that we can check later.
*/
- SetThreadPriority(threadH, PTW32TEST_THREAD_INIT_PRIO);
- SetThreadPriority(threadH, prioSet);
- validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
+ param.sched_priority = prioSet;
+ assert(pthread_setschedparam(thread, SCHED_OTHER, &param) == 0);
+ validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
}
return (void *) 0;
@@ -155,7 +156,9 @@ main()
assert(pthread_setschedparam(mainThread, SCHED_OTHER, &mainParam) == 0);
assert(pthread_getschedparam(mainThread, &policy, &mainParam) == 0);
assert(policy == SCHED_OTHER);
- assert(mainParam.sched_priority ==
+ /* Priority returned below should be the level set by pthread_setschedparam(). */
+ assert(mainParam.sched_priority == prio);
+ assert(GetThreadPriority(threadH) ==
validPriorities[prio+(PTW32TEST_MAXPRIORITIES/2)]);
for (param.sched_priority = prio;
diff --git a/tests/priority1.c b/tests/priority1.c
index 48af6f7..1dc6ea7 100644
--- a/tests/priority1.c
+++ b/tests/priority1.c
@@ -101,6 +101,9 @@ getValidPriorities(void * arg)
pthread_t threadID = pthread_self();
HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+ printf("Using GetThreadPriority\n");
+ printf("%10s %10s\n", "Set value", "Get value");
+
for (prioSet = minPrio;
prioSet <= maxPrio;
prioSet++)
@@ -110,9 +113,13 @@ getValidPriorities(void * arg)
* from the previous value. Make the previous value a known
* one so that we can check later.
*/
- SetThreadPriority(threadH, PTW32TEST_THREAD_INIT_PRIO);
+ if (prioSet < 0)
+ SetThreadPriority(threadH, THREAD_PRIORITY_LOWEST);
+ else
+ SetThreadPriority(threadH, THREAD_PRIORITY_HIGHEST);
SetThreadPriority(threadH, prioSet);
validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
+ printf("%10d %10d\n", prioSet, validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)]);
}
return (void *) 0;
@@ -140,15 +147,23 @@ main()
SetThreadPriority(pthread_getw32threadhandle_np(pthread_self()),
PTW32TEST_THREAD_INIT_PRIO);
+ printf("Using pthread_getschedparam\n");
+ printf("%10s %10s\n", "Set value", "Get value");
+
for (param.sched_priority = minPrio;
param.sched_priority <= maxPrio;
param.sched_priority++)
{
assert(pthread_attr_setschedparam(&attr, &param) == 0);
assert(pthread_create(&t, &attr, func, (void *) &attr) == 0);
+
+ assert(GetThreadPriority(pthread_getw32threadhandle_np(t))
+ == validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
+
assert(pthread_join(t, &result) == 0);
- assert((int) result ==
- validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
+
+ assert(param.sched_priority == (int) result);
+ printf("%10d %10d\n", param.sched_priority, (int) result);
}
return 0;
diff --git a/tests/priority2.c b/tests/priority2.c
index 54fd3a0..fc19ed5 100644
--- a/tests/priority2.c
+++ b/tests/priority2.c
@@ -81,27 +81,31 @@ enum {
int minPrio;
int maxPrio;
int validPriorities[PTW32TEST_MAXPRIORITIES];
-pthread_mutex_t startMx = PTHREAD_MUTEX_INITIALIZER;
+pthread_barrier_t startBarrier, endBarrier;
void * func(void * arg)
{
int policy;
+ int result;
struct sched_param param;
- assert(pthread_mutex_lock(&startMx) == 0);
+ result = pthread_barrier_wait(&startBarrier);
+ assert(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
assert(pthread_getschedparam(pthread_self(), &policy, &param) == 0);
- assert(pthread_mutex_unlock(&startMx) == 0);
assert(policy == SCHED_OTHER);
+ result = pthread_barrier_wait(&endBarrier);
+ assert(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
return (void *) param.sched_priority;
}
-
+
void *
getValidPriorities(void * arg)
{
int prioSet;
- pthread_t threadID = pthread_self();
- HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+ pthread_t thread = pthread_self();
+ HANDLE threadH = pthread_getw32threadhandle_np(thread);
+ struct sched_param param;
for (prioSet = minPrio;
prioSet <= maxPrio;
@@ -112,8 +116,8 @@ getValidPriorities(void * arg)
* from the previous value. Make the previous value a known
* one so that we can check later.
*/
- SetThreadPriority(threadH, PTW32TEST_THREAD_INIT_PRIO);
- SetThreadPriority(threadH, prioSet);
+ param.sched_priority = prioSet;
+ assert(pthread_setschedparam(thread, SCHED_OTHER, &param) == 0);
validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
}
@@ -126,6 +130,7 @@ main()
{
pthread_t t;
void * result = NULL;
+ int result2;
struct sched_param param;
assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
@@ -134,6 +139,9 @@ main()
assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
assert(pthread_join(t, &result) == 0);
+ assert(pthread_barrier_init(&startBarrier, NULL, 2) == 0);
+ assert(pthread_barrier_init(&endBarrier, NULL, 2) == 0);
+
/* Set the thread's priority to a known initial value.
* If the new priority is invalid then the threads priority
* is unchanged from the previous value.
@@ -145,13 +153,16 @@ main()
param.sched_priority <= maxPrio;
param.sched_priority++)
{
- assert(pthread_mutex_lock(&startMx) == 0);
assert(pthread_create(&t, NULL, func, NULL) == 0);
assert(pthread_setschedparam(t, SCHED_OTHER, &param) == 0);
- assert(pthread_mutex_unlock(&startMx) == 0);
- pthread_join(t, &result);
- assert((int) result ==
+ result2 = pthread_barrier_wait(&startBarrier);
+ assert(result2 == 0 || result2 == PTHREAD_BARRIER_SERIAL_THREAD);
+ result2 = pthread_barrier_wait(&endBarrier);
+ assert(result2 == 0 || result2 == PTHREAD_BARRIER_SERIAL_THREAD);
+ assert(GetThreadPriority(pthread_getw32threadhandle_np(t)) ==
validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
+ pthread_join(t, &result);
+ assert(param.sched_priority == (int)result);
}
return 0;
diff --git a/tests/sizes.c b/tests/sizes.c
new file mode 100644
index 0000000..709c610
--- /dev/null
+++ b/tests/sizes.c
@@ -0,0 +1,28 @@
+#include "test.h"
+#include "../implement.h"
+
+int
+main()
+{
+ printf("Sizes of pthreads-win32 structs\n");
+ printf("-------------------------------\n");
+ printf("%30s %4d\n", "pthread_t_", sizeof(struct pthread_t_));
+ printf("%30s %4d\n", "pthread_attr_t_", sizeof(struct pthread_attr_t_));
+ printf("%30s %4d\n", "sem_t_", sizeof(struct sem_t_));
+ printf("%30s %4d\n", "pthread_mutex_t_", sizeof(struct pthread_mutex_t_));
+ printf("%30s %4d\n", "pthread_mutexattr_t_", sizeof(struct pthread_mutexattr_t_));
+ printf("%30s %4d\n", "pthread_spinlock_t_", sizeof(struct pthread_spinlock_t_));
+ printf("%30s %4d\n", "pthread_barrier_t_", sizeof(struct pthread_barrier_t_));
+ printf("%30s %4d\n", "pthread_barrierattr_t_", sizeof(struct pthread_barrierattr_t_));
+ printf("%30s %4d\n", "pthread_key_t_", sizeof(struct pthread_key_t_));
+ printf("%30s %4d\n", "pthread_cond_t_", sizeof(struct pthread_cond_t_));
+ printf("%30s %4d\n", "pthread_condattr_t_", sizeof(struct pthread_condattr_t_));
+ printf("%30s %4d\n", "pthread_rwlock_t_", sizeof(struct pthread_rwlock_t_));
+ printf("%30s %4d\n", "pthread_rwlockattr_t_", sizeof(struct pthread_rwlockattr_t_));
+ printf("%30s %4d\n", "pthread_once_t_", sizeof(struct pthread_once_t_));
+ printf("%30s %4d\n", "ptw32_cleanup_t", sizeof(struct ptw32_cleanup_t));
+ printf("%30s %4d\n", "sched_param", sizeof(struct sched_param));
+ printf("-------------------------------\n");
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-31 22:36:18 +0000