* GNUmakefile (libwsock32): Add to linker flags for

        WSAGetLastError() and WSASetLastError().
        * Makefile (wsock32.lib): Likewise.
        * create.c: Minor mostly inert changes.
        * implement.h (PTW32_MAX): Move into here and renamed
        from sched.h.
        (PTW32_MIN): Likewise.
        * GNUmakefile (TEST_ICE): Define if testing internal
        implementation of InterlockedCompareExchange.
        * Makefile (TEST_ICE): Likewise.
        * private.c (TEST_ICE): Likewise.

10 files changed, 307 insertions, 28 deletions

diff --git a/tests/ChangeLog b/tests/ChangeLog
index 93e6342..77d81db 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,15 @@
+2001-10-25  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>

+

+	* condvar2.c: Remove reference to cv->nWaitersUnblocked.

+	* condvar2_1.c: Likewise; lower NUMTHREADS from 60 to 30.

+	* condvar3_1.c: Likewise.

+	* condvar3_2.c: Likewise.

+	* count1.c: lower NUMTHREADS from 60 to 30.

+	* inherit1.c: Determine valid priority values and then

+	assert values returned by POSIX routines are the same.

+	* priority1.c: Likewise.

+	* priority2.c: Likewise.

+	

 2001-07-12  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>

 

 	* barrier5.c: Assert that precisely one thread receives

diff --git a/tests/benchtest5.c b/tests/benchtest5.c
new file mode 100644
index 0000000..0bdaf90
--- /dev/null
+++ b/tests/benchtest5.c
@@ -0,0 +1,141 @@
+/*
+ * benchtest5.c
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Semaphore
+ *   Single thread iteration over post/wait for a semaphore.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define ITERATIONS      10000000L
+
+sem_t sema;
+
+struct _timeb currSysTimeStart;
+struct _timeb currSysTimeStop;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0; _ftime(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  }; _ftime(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void
+reportTest (char * testNameString)
+{
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-40s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  printf( "========================================================================\n");
+  printf( "\nOperations on a semaphore.\n%ld iterations\n\n",
+          ITERATIONS);
+  printf( "%-40s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  TESTSTART
+  assert(1 == 1);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  /*
+   * Now we can start the actual tests
+   */
+  assert(sem_init(&sema, 0, 0) == 0);
+  TESTSTART
+  assert(sem_post(&sema) == 0);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("Post");
+
+
+  assert(sem_init(&sema, 0, ITERATIONS) == 0);
+  TESTSTART
+  assert(sem_wait(&sema) == 0);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("Wait without blocking");
+
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  TESTSTART
+  assert(1 == 1);
+  assert(1 == 1);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  /*
+   * Now we can start the actual tests
+   */
+  assert(sem_init(&sema, 0, 0) == 0);
+  TESTSTART
+  assert(sem_post(&sema) == 0);
+  assert(sem_wait(&sema) == 0);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("Post then Wait without blocking");
+
+
+  assert(sem_init(&sema, 0, 1) == 0);
+  TESTSTART
+  assert(sem_wait(&sema) == 0);
+  assert(sem_post(&sema) == 0);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("Wait then Post without blocking");
+
+  printf( "========================================================================\n");
+
+  /*
+   * End of tests.
+   */
+
+  return 0;
+}
diff --git a/tests/condvar2.c b/tests/condvar2.c
index 369cef6..211f0ec 100644
--- a/tests/condvar2.c
+++ b/tests/condvar2.c
@@ -80,7 +80,6 @@ main()
     {
       fprintf(stderr, "Result = %s\n", error_string[result]);
 	fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
-	fprintf(stderr, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
 	fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
 	fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
 	fflush(stderr);
diff --git a/tests/condvar2_1.c b/tests/condvar2_1.c
index feae128..32bf9fc 100644
--- a/tests/condvar2_1.c
+++ b/tests/condvar2_1.c
@@ -49,7 +49,7 @@ static pthread_mutex_t mutex;
 static struct timespec abstime = { 0, 0 };
 
 enum {
-  NUMTHREADS = 60
+  NUMTHREADS = 30
 };
 
 void *
@@ -108,7 +108,6 @@ main()
     {
       fprintf(stderr, "Result = %s\n", error_string[result]);
 	fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
-	fprintf(stderr, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
 	fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
 	fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
 	fflush(stderr);
diff --git a/tests/condvar3_1.c b/tests/condvar3_1.c
index ea5f33f..4cf460a 100644
--- a/tests/condvar3_1.c
+++ b/tests/condvar3_1.c
@@ -56,7 +56,7 @@ static int awoken = 0;
 static int waiting = 0;
 
 enum {
-  NUMTHREADS = 60
+  NUMTHREADS = 30
 };
 
 void *
@@ -146,7 +146,6 @@ main()
     {
       fprintf(stderr, "Result = %s\n", error_string[result]);
         fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
-        fprintf(stderr, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
         fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
         fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
         fflush(stderr);
diff --git a/tests/condvar3_2.c b/tests/condvar3_2.c
index e5f451b..e2ccfd0 100644
--- a/tests/condvar3_2.c
+++ b/tests/condvar3_2.c
@@ -54,7 +54,7 @@ static int timedout = 0;
 static int awoken = 0;
 
 enum {
-  NUMTHREADS = 60
+  NUMTHREADS = 30
 };
 
 void *
@@ -140,7 +140,6 @@ main()
     {
       fprintf(stderr, "Result = %s\n", error_string[result]);
 	fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
-	fprintf(stderr, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
 	fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
 	fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
 	fflush(stderr);
diff --git a/tests/count1.c b/tests/count1.c
index ae30ed0..b00f7b3 100644
--- a/tests/count1.c
+++ b/tests/count1.c
@@ -7,11 +7,7 @@
 
 #include "test.h"
 
-#if ! defined (__MINGW32__) || defined (__MSVCRT__)
-#define NUMTHREADS (60)
-#else
-#define NUMTHREADS (59)
-#endif
+#define NUMTHREADS (30)
 
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_t threads[NUMTHREADS];
diff --git a/tests/inherit1.c b/tests/inherit1.c
index a909eb7..2263cc6 100644
--- a/tests/inherit1.c
+++ b/tests/inherit1.c
@@ -41,6 +41,16 @@
 
 #include "test.h"
 
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
+
+
 void * func(void * arg)
 {
   int policy;
@@ -50,6 +60,32 @@ void * func(void * arg)
   return (void *) param.sched_priority;
 }
 
+
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+
+  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);
+    }
+
+  return (void *) 0;
+}
+
+
 int
 main()
 {
@@ -59,29 +95,36 @@ main()
   void * result = NULL;
   struct sched_param param;
   struct sched_param mainParam;
-  int maxPrio;
-  int minPrio;
   int prio;
   int policy;
   int inheritsched = -1;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
 
   assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
   assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
 
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
+
   assert(pthread_attr_init(&attr) == 0);
   assert(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED) == 0);
   assert(pthread_attr_getinheritsched(&attr, &inheritsched) == 0);
   assert(inheritsched == PTHREAD_INHERIT_SCHED);
 
-  for (prio = minPrio; prio < maxPrio; prio++)
+  for (prio = minPrio; prio <= maxPrio; prio++)
     {
       mainParam.sched_priority = prio;
 
+      /* Set the thread's priority to a known initial value. */
+      SetThreadPriority(threadH, PTW32TEST_THREAD_INIT_PRIO);
+
       /* Change the main thread priority */
       assert(pthread_setschedparam(mainThread, SCHED_OTHER, &mainParam) == 0);
       assert(pthread_getschedparam(mainThread, &policy, &mainParam) == 0);
       assert(policy == SCHED_OTHER);
-      assert(mainParam.sched_priority == prio);
+      assert(mainParam.sched_priority ==
+               validPriorities[prio+(PTW32TEST_MAXPRIORITIES/2)]);
 
       for (param.sched_priority = prio;
            param.sched_priority <= maxPrio;
diff --git a/tests/priority1.c b/tests/priority1.c
index a311028..1ec9f4d 100644
--- a/tests/priority1.c
+++ b/tests/priority1.c
@@ -41,16 +41,52 @@
 
 #include "test.h"
 
-void * func(void * arg)
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
+
+void *
+func(void * arg)
 {
   int policy;
   struct sched_param param;
+  pthread_t threadID = pthread_self();
 
-  assert(pthread_getschedparam(pthread_self(), &policy, &param) == 0);
+  assert(pthread_getschedparam(threadID, &policy, &param) == 0);
   assert(policy == SCHED_OTHER);
-  return (void *) param.sched_priority;
+  return (void *) (param.sched_priority);
+}
+
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+
+  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);
+    }
+
+  return (void *) 0;
 }
- 
+
+
 int
 main()
 {
@@ -58,20 +94,29 @@ main()
   pthread_attr_t attr;
   void * result = NULL;
   struct sched_param param;
-  int maxPrio = sched_get_priority_max(SCHED_OTHER);
-  int minPrio = sched_get_priority_min(SCHED_OTHER);
+
+  assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
+  assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
+
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
 
   assert(pthread_attr_init(&attr) == 0);
   assert(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0);
 
+  /* Set the thread's priority to a known initial value. */
+  SetThreadPriority(pthread_getw32threadhandle_np(pthread_self()),
+                    PTW32TEST_THREAD_INIT_PRIO);
+
   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, NULL) == 0);
-      pthread_join(t, &result);
-      assert((int) result == param.sched_priority);
+      assert(pthread_create(&t, &attr, func, (void *) &attr) == 0);
+      assert(pthread_join(t, &result) == 0);
+      assert((int) result ==
+	  validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
     }
 
   return 0;
diff --git a/tests/priority2.c b/tests/priority2.c
index 4dcf385..06a5a13 100644
--- a/tests/priority2.c
+++ b/tests/priority2.c
@@ -41,6 +41,14 @@
 
 #include "test.h"
 
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
 pthread_mutex_t startMx = PTHREAD_MUTEX_INITIALIZER;
 
 void * func(void * arg)
@@ -54,15 +62,52 @@ void * func(void * arg)
   assert(policy == SCHED_OTHER);
   return (void *) param.sched_priority;
 }
+
  
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+
+  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);
+    }
+
+  return (void *) 0;
+}
+
+
 int
 main()
 {
   pthread_t t;
   void * result = NULL;
   struct sched_param param;
-  int maxPrio = sched_get_priority_max(SCHED_OTHER);
-  int minPrio = sched_get_priority_min(SCHED_OTHER);
+
+  assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
+  assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
+
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 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.
+   */
+  SetThreadPriority(pthread_getw32threadhandle_np(pthread_self()),
+                    PTW32TEST_THREAD_INIT_PRIO);
 
   for (param.sched_priority = minPrio;
        param.sched_priority <= maxPrio;
@@ -73,7 +118,8 @@ main()
       assert(pthread_setschedparam(t, SCHED_OTHER, &param) == 0);
       assert(pthread_mutex_unlock(&startMx) == 0);
       pthread_join(t, &result);
-      assert((int) result == param.sched_priority);
+      assert((int) result ==
+	  validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
     }
 
   return 0;