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.

5 files changed, 52 insertions, 34 deletions

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  <rpj@setup1.ise.canberra.edu.au>
+
+	* spin3.c: Changed test and fixed.
+	* spin4.c: Fixed.
+	* barrier3.c: Fixed.
+	* barrier4.c: Fixed.
+
 2001-07-05  Ross Johnson  <rpj@special.ise.canberra.edu.au>
 
 	* 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 <sys/timeb.h>
  
-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();