From 06974b302eaf8f08382e6e786aea53f420c12222 Mon Sep 17 00:00:00 2001 From: rpj Date: Fri, 6 Jul 2001 18:16:50 +0000 Subject: Spinlocks and barriers fixed and working. Beta level. * spin.c: Revamped and working; included static initialiser. * barrier.c: Likewise. * condvar.c: Macro constant change; inline auto init routine. * mutex.c: Likewise. * rwlock.c: Likewise. * private.c: Add support for spinlock initialiser. * global.c: Likewise. * implement.h: Likewise. * pthread.h (PTHREAD_SPINLOCK_INITIALIZER): Fix typo. tests/ChangeLog: * spin3.c: Changed test and fixed. * spin4.c: Fixed. * barrier3.c: Fixed. * barrier4.c: Fixed. --- tests/ChangeLog | 7 +++++++ tests/barrier3.c | 19 +++++++++---------- tests/barrier4.c | 39 +++++++++++++++++++++++---------------- tests/spin3.c | 2 +- tests/spin4.c | 19 ++++++++++++------- 5 files changed, 52 insertions(+), 34 deletions(-) (limited to 'tests') diff --git a/tests/ChangeLog b/tests/ChangeLog index 565f0ad..1c5d766 100644 --- a/tests/ChangeLog +++ b/tests/ChangeLog @@ -1,3 +1,10 @@ +2001-07-07 Ross Johnson + + * spin3.c: Changed test and fixed. + * spin4.c: Fixed. + * barrier3.c: Fixed. + * barrier4.c: Fixed. + 2001-07-05 Ross Johnson * spin1.c: New; testing spinlocks. diff --git a/tests/barrier3.c b/tests/barrier3.c index 497b76a..97f6dc2 100644 --- a/tests/barrier3.c +++ b/tests/barrier3.c @@ -1,7 +1,7 @@ /* * barrier3.c * - * Declare a single barrier object, multiple wait on it, + * Declare a single barrier object with barrier attribute, wait on it, * and then destroy it. * */ @@ -9,8 +9,7 @@ #include "test.h" pthread_barrier_t barrier = NULL; -static int result1 = -1; -static int result2 = -1; +static int result = 1; void * func(void * arg) { @@ -21,20 +20,20 @@ int main() { pthread_t t; + pthread_barrierattr_t ba; - assert(pthread_barrier_init(&barrier, NULL, 2) == 0); + assert(pthread_barrierattr_init(&ba) == 0); + assert(pthread_barrierattr_setpshared(&ba, PTHREAD_PROCESS_PRIVATE) == 0); + assert(pthread_barrier_init(&barrier, &ba, 1) == 0); assert(pthread_create(&t, NULL, func, NULL) == 0); - result1 = pthread_barrier_wait(&barrier); + assert(pthread_join(t, (void *) &result) == 0); - assert(pthread_join(t, &result2) == 0); - - assert(result1 != result2); - assert(result1 == 0 || result1 == PTHREAD_BARRIER_SERIAL_THREAD); - assert(result2 == 0 || result2 == PTHREAD_BARRIER_SERIAL_THREAD); + assert(result == PTHREAD_BARRIER_SERIAL_THREAD); assert(pthread_barrier_destroy(&barrier) == 0); + assert(pthread_barrierattr_destroy(&ba) == 0); return 0; } diff --git a/tests/barrier4.c b/tests/barrier4.c index 1dd8291..8f33e85 100644 --- a/tests/barrier4.c +++ b/tests/barrier4.c @@ -14,12 +14,11 @@ enum { pthread_barrier_t barrier = NULL; pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER; -static int result1 = -1; -static int result2 = -1; static int serialThreadCount = 0; static int otherThreadCount = 0; -void * func(void * arg) +void * +func(void * arg) { int result = pthread_barrier_wait(&barrier); @@ -32,31 +31,39 @@ void * func(void * arg) { otherThreadCount++; } - assert(pthread_mutex_lock(&mx) == 0); + assert(pthread_mutex_unlock(&mx) == 0); return NULL; } - + int main() { + int i, j; pthread_t t[NUMTHREADS + 1]; - assert(pthread_barrier_init(&barrier, NULL, NUMTHREADS) == 0); - - for (i = 0; i < NUMTHREADS; i++) + for (j = 1; j <= NUMTHREADS; j++) { - assert(pthread_create(&t[i], NULL, func, NULL) == 0); - } + printf("Barrier height = %d\n", j); - for (i = 0; i < NUMTHREADS; i++) - { - assert(pthread_join(t[i], NULL) == 0); - } + serialThreadCount = 0; + + assert(pthread_barrier_init(&barrier, NULL, j) == 0); + + for (i = 1; i <= j; i++) + { + assert(pthread_create(&t[i], NULL, func, NULL) == 0); + } - assert(serialThreadCount == 1); + for (i = 1; i <= j; i++) + { + assert(pthread_join(t[i], NULL) == 0); + } - assert(pthread_barrier_destroy(&barrier) == 0); + assert(serialThreadCount == 1); + + assert(pthread_barrier_destroy(&barrier) == 0); + } assert(pthread_mutex_destroy(&mx) == 0); diff --git a/tests/spin3.c b/tests/spin3.c index 8b383de..acd6e75 100644 --- a/tests/spin3.c +++ b/tests/spin3.c @@ -26,7 +26,6 @@ int main() { pthread_t t; - pthread_spinattr_t ma; wasHere = 0; assert(pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE) == 0); @@ -34,6 +33,7 @@ main() assert(pthread_create(&t, NULL, unlocker, (void *) 0) == 0); assert(pthread_join(t, NULL) == 0); assert(pthread_spin_unlock(&spin) == EPERM); + assert(pthread_spin_destroy(&spin) == 0); assert(wasHere == 2); return 0; diff --git a/tests/spin4.c b/tests/spin4.c index a435d04..5f04a27 100644 --- a/tests/spin4.c +++ b/tests/spin4.c @@ -1,19 +1,14 @@ /* * spin4.c * - * Declare a spinlock object, lock it, spin on it, + * Declare a static spinlock object, lock it, spin on it, * and then unlock it again. - * - * For this to work on a single processor machine we have - * to static initialise the spinlock. This bypasses the - * check of the number of processors done by pthread_spin_init. - * This is a non-portable side-effect of this implementation. */ #include "test.h" #include -pthread_spinlock_t lock = PTHREADS_SPINLOCK_INITIALIZER; +pthread_spinlock_t lock = PTHREAD_SPINLOCK_INITIALIZER; struct _timeb currSysTimeStart; struct _timeb currSysTimeStop; @@ -37,7 +32,16 @@ int main() { long result = 0; + int i; pthread_t t; + int CPUs; + + if (pthread_getprocessors_np(&CPUs) != 0 || CPUs == 1) + { + printf("This test is not applicable to this system.\n"); + printf("Either there is only 1 CPU or the no. could not be determined.\n"); + exit(0); + } assert(pthread_spin_lock(&lock) == 0); @@ -47,6 +51,7 @@ main() * This should relinqish the CPU to the func thread enough times * to waste approximately 2000 millisecs only if the lock really * is spinning in the func thread (assuming 10 millisec CPU quantum). + */ for (i = 0; i < 200; i++) { sched_yield(); -- cgit v1.2.3