pthreads:

2001-06-03  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>

        Contributed by  - Alexander Terekhov <TEREKHOV@de.ibm.com>
                        - Louis Thomas <lthomas@arbitrade.com>

        * condvar.c (pthread_cond_init): Completely revamped.
        (pthread_cond_destroy): Likewise.
        (ptw32_cond_wait_cleanup): Likewise.
        (ptw32_cond_timedwait): Likewise.
        (ptw32_cond_unblock): New general signaling routine.
        (pthread_cond_signal): Now calls ptw32_cond_unblock.
        (pthread_cond_broadcast): Likewise.
        * implement.h (pthread_cond_t_): Revamped.
        * README.CV: New; explanation of the above changes.

pthreads/tests:
2001-06-3  Ross Johnson  <rpj@special.ise.canberra.edu.au>

        * condvar2_1.c: New test.
        * condvar3_1.c: New test.
        * condvar3_2.c: New test.

7 files changed, 453 insertions, 11 deletions

diff --git a/tests/ChangeLog b/tests/ChangeLog
index b1b3881..e7026f2 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,9 @@
+2001-06-3  Ross Johnson  <rpj@special.ise.canberra.edu.au>

+

+	* condvar2_1.c: New test.

+	* condvar3_1.c: New test.

+	* condvar3_2.c: New test.

+

 2001-05-30  Ross Johnson  <rpj@special.ise.canberra.edu.au>

 

 	* mutex1n.c: New test.

diff --git a/tests/GNUmakefile b/tests/GNUmakefile
index d38f982..b14db76 100644
--- a/tests/GNUmakefile
+++ b/tests/GNUmakefile
@@ -36,11 +36,12 @@ COPYFILES	= $(HDR) $(LIB) $(DLL)
 # stop.
 
 TESTS	= loadfree \
-	  self1 mutex5 mutex1 mutex1e mutex1n mutex1r condvar1 condvar2 exit1 create1 equal1 \
+	  self1 mutex5 mutex1 mutex1e mutex1n mutex1r \
+	  condvar1 condvar2 condvar2_1 exit1 create1 equal1 \
 	  exit2 exit3 \
 	  join0 join1 join2 mutex2 mutex3 mutex4 mutex6 mutex6n mutex6e mutex6r \
 	  count1 once1 tsd1 self2 cancel1 cancel2 eyal1 \
-	  condvar3 condvar4 condvar5 condvar6 condvar7 condvar8 condvar9 \
+	  condvar3 condvar3_1 condvar3_2 condvar4 condvar5 condvar6 condvar7 condvar8 condvar9 \
 	  errno1 \
 	  rwlock1 rwlock2 rwlock3 rwlock4 rwlock5 rwlock6 rwlock7 \
 	  context1 cancel3 cancel4 cancel5 \
@@ -72,6 +73,7 @@ all-GCE: $(PASSES)
 
 cancel1.pass: create1.pass
 cancel2.pass: cancel1.pass
+cancel2_1.pass: cancel2.pass
 cancel3.pass: context1.pass
 cancel4.pass: cancel3.pass
 cancel5.pass: cancel3.pass
@@ -81,7 +83,10 @@ cleanup2.pass: cleanup1.pass
 cleanup3.pass: cleanup2.pass
 condvar1.pass:
 condvar2.pass: condvar1.pass
-condvar3.pass: create1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
 condvar4.pass: create1.pass
 condvar5.pass: condvar4.pass
 condvar6.pass: condvar5.pass
diff --git a/tests/Makefile b/tests/Makefile
index 5915d54..afcc156 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -39,7 +39,7 @@ EHFLAGS	=
 PASSES= loadfree.pass \

 	  self1.pass mutex5.pass  \

 	  mutex1.pass  mutex1n.pass  mutex1e.pass  mutex1r.pass  mutex2.pass  mutex3.pass  \

-	  condvar1.pass  condvar2.pass  \

+	  condvar1.pass  condvar2.pass  condvar2_1.pass  \

 	  exit1.pass  create1.pass  equal1.pass  \

 	  exit2.pass  exit3.pass  \

 	  join0.pass  join1.pass  join2.pass  \

@@ -48,7 +48,7 @@ PASSES= loadfree.pass \
 	  self2.pass  \

 	  cancel1.pass  cancel2.pass  \

 	  eyal1.pass  \

-	  condvar3.pass  condvar4.pass  condvar5.pass  condvar6.pass  \

+	  condvar3.pass  condvar3_1.pass  condvar3_2.pass  condvar4.pass  condvar5.pass  condvar6.pass  \

 	  condvar7.pass  condvar8.pass  condvar9.pass  \

 	  errno1.pass  \

 	  rwlock1.pass  rwlock2.pass  rwlock3.pass  rwlock4.pass  rwlock5.pass  rwlock6.pass  rwlock7.pass  \

@@ -125,7 +125,10 @@ cleanup2.pass: cleanup1.pass
 cleanup3.pass: cleanup2.pass

 condvar1.pass:

 condvar2.pass: condvar1.pass

-condvar3.pass: create1.pass

+condvar2_1.pass: condvar2.pass join2.pass

+condvar3.pass: create1.pass condvar2.pass

+condvar3_1.pass: condvar3.pass join2.pass

+condvar3_2.pass: condvar3_1.pass

 condvar4.pass: create1.pass

 condvar5.pass: condvar4.pass

 condvar6.pass: condvar5.pass

diff --git a/tests/condvar2.c b/tests/condvar2.c
index beae323..369cef6 100644
--- a/tests/condvar2.c
+++ b/tests/condvar2.c
@@ -1,5 +1,5 @@
 /*
- * File: condvar1.c
+ * File: condvar2.c
  *
  * Test Synopsis:
  * - Test timed wait on a CV.
@@ -47,6 +47,8 @@
 pthread_cond_t cv;
 pthread_mutex_t mutex;
 
+#include "../implement.h"
+
 int
 main()
 {
@@ -72,10 +74,19 @@ main()
   
   assert(pthread_mutex_unlock(&mutex) == 0);
 
-  assert(pthread_cond_destroy(&cv) == 0);
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      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);
+    }
+  assert(result == 0);
+  }
 
   return 0;
 }
-
-
-
diff --git a/tests/condvar2_1.c b/tests/condvar2_1.c
new file mode 100644
index 0000000..feae128
--- /dev/null
+++ b/tests/condvar2_1.c
@@ -0,0 +1,120 @@
+/*
+ * File: condvar2_1.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with no signal/broadcast.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because the CV is never signaled, we expect the waits to time out.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+
+enum {
+  NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  int result = 0;
+  struct _timeb currSysTime;
+  const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  /* get current system time */
+  _ftime(&currSysTime);
+
+  abstime.tv_sec = currSysTime.time;
+  abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+  abstime.tv_sec += 5;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], (void **) &result) == 0);
+	assert(result == i);
+    }
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      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);
+    }
+  assert(result == 0);
+  }
+
+  return 0;
+}
diff --git a/tests/condvar3_1.c b/tests/condvar3_1.c
new file mode 100644
index 0000000..f9bb0c6
--- /dev/null
+++ b/tests/condvar3_1.c
@@ -0,0 +1,144 @@
+/*
+ * File: condvar3_1.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with some signaled.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ *   Some are signaled, the rest time out. Pthread_cond_destroy() will fail
+ *   unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+static int timedout = 0;
+static int signaled = 0;
+static int awoken = 0;
+
+enum {
+  NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+  int result;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  result = pthread_cond_timedwait(&cv, &mutex, &abstime);
+  if (result == ETIMEDOUT)
+    {
+      timedout++;
+    }
+  else
+    {
+      awoken++;
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  int result = 0;
+  struct _timeb currSysTime;
+  const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  /* get current system time */
+  _ftime(&currSysTime);
+
+  abstime.tv_sec = currSysTime.time;
+  abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+  abstime.tv_sec += 5;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  for (i = NUMTHREADS/3; i <= 2*NUMTHREADS/3; i++)
+    {
+      assert(pthread_cond_signal(&cv) == 0);
+      signaled++;
+    }
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], (void **) &result) == 0);
+	assert(result == i);
+    }
+
+  assert(signaled == awoken);
+  assert(timedout == NUMTHREADS - signaled);
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      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);
+    }
+  assert(result == 0);
+  }
+
+  return 0;
+}
diff --git a/tests/condvar3_2.c b/tests/condvar3_2.c
new file mode 100644
index 0000000..cd1565d
--- /dev/null
+++ b/tests/condvar3_2.c
@@ -0,0 +1,153 @@
+/*
+ * File: condvar3_2.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with remainder broadcast awoken.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ *   Some time out, the rest are broadcast signaled. Pthread_cond_destroy() will fail
+ *   unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+static struct timespec abstime2 = { 0, 0 };
+static int timedout = 0;
+static int signaled = 0;
+static int awoken = 0;
+
+enum {
+  NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+  int result;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  abstime2.tv_sec = abstime.tv_sec;
+
+  if ((int) arg % 3 == 0)
+    {
+      abstime2.tv_sec += 2;
+    }
+
+  result = pthread_cond_timedwait(&cv, &mutex, &abstime2);
+  if (result == ETIMEDOUT)
+    {
+      timedout++;
+    }
+  else
+    {
+      awoken++;
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  int result = 0;
+  struct _timeb currSysTime;
+  const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  /* get current system time */
+  _ftime(&currSysTime);
+
+  abstime.tv_sec = abstime.tv_sec = currSysTime.time + 5;
+  abstime.tv_nsec = abstime2.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], (void **) &result) == 0);
+	assert(result == i);
+      /*
+       * Approximately 2/3rds of the threads are expected to time out.
+       * Signal the remainder after some threads have woken up and exited
+       * and while some are still waking up after timeout.
+       * Also tests that redundant broadcasts don't return errors.
+       */
+      if (awoken > NUMTHREADS/3)
+        {
+          assert(pthread_cond_broadcast(&cv) == 0);
+        }
+    }
+
+  assert(awoken == NUMTHREADS - timedout);
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      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);
+    }
+  assert(result == 0);
+  }
+
+  return 0;
+}