Merge pull request #9628 from awlauria/make_check_picks

v5.0.x: tests: Backporting some fixes from master

Author: awlauria

test/threads/Makefile.am

@@ -28,9 +28,7 @@ check_PROGRAMS = \
 	opal_condition \
 	opal_atomic_thread_bench
 
-# JMS possibly to be re-added when #1232 is fixed
-#TESTS = $(check_PROGRAMS)
-TESTS =
+TESTS = $(check_PROGRAMS)
 
 opal_thread_SOURCES = opal_thread.c
 opal_thread_LDADD = \

test/threads/opal_atomic_thread_bench.c

@@ -22,6 +22,65 @@
 #define ITERATIONS 1000000
 #define ITEM_COUNT 100
 
+#ifdef __APPLE__
+/* pthread barrier implementation copied from stack overflow.
+ * Source:
+ * https://stackoverflow.com/questions/3640853/performance-test-sem-t-v-s-dispatch-semaphore-t-and-pthread-once-t-v-s-dispatch
+ */
+typedef int pthread_barrierattr_t;
+struct pthread_barrier_t {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int count;
+    int tripCount;
+};
+
+typedef struct pthread_barrier_t pthread_barrier_t;
+
+int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr,
+                         unsigned int count)
+{
+    if (count == 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    if (pthread_mutex_init(&barrier->mutex, 0) < 0) {
+        return -1;
+    }
+    if (pthread_cond_init(&barrier->cond, 0) < 0) {
+        pthread_mutex_destroy(&barrier->mutex);
+        return -1;
+    }
+    barrier->tripCount = count;
+    barrier->count = 0;
+
+    return 0;
+}
+
+int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+    pthread_cond_destroy(&barrier->cond);
+    pthread_mutex_destroy(&barrier->mutex);
+    return 0;
+}
+
+int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+    pthread_mutex_lock(&barrier->mutex);
+    ++(barrier->count);
+    if (barrier->count >= barrier->tripCount) {
+        barrier->count = 0;
+        pthread_cond_broadcast(&barrier->cond);
+        pthread_mutex_unlock(&barrier->mutex);
+        return 1;
+    }
+
+    pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+    pthread_mutex_unlock(&barrier->mutex);
+    return 0;
+}
+#endif
+
 static opal_atomic_int64_t var_64 = 0;
 static opal_atomic_int32_t var_32 = 0;
 static pthread_barrier_t   barrier;

test/threads/opal_condition.c

@@ -42,40 +42,47 @@ static volatile int thr2_count = 0;
 
 static void* thr1_run(opal_object_t* obj)
 {
-    int i;
     clock_t c1, c2;
-    opal_mutex_lock(&mutex);
     c1 = clock();
-    for(i=0; i<TEST_COUNT; i++) {
-        opal_condition_wait(&thr1_cond, &mutex);
-        opal_condition_signal(&thr2_cond);
+    opal_mutex_lock(&mutex);
+    while (TEST_COUNT != thr1_count) {
         thr1_count++;
+        opal_condition_signal(&thr2_cond);
+        opal_condition_wait(&thr1_cond, &mutex);
     }
-    c2 = clock();
+
+    // Whoever gets here first needs to alert the other
+    // thread for their last iteration.
+    opal_condition_signal(&thr2_cond);
     opal_mutex_unlock(&mutex);
-    fprintf(stderr, "thr1: time per iteration: %ld usec\n", (long)((c2 - c1) / TEST_COUNT));
+    c2 = clock();
+    fprintf(stderr, "thr1: time per iteration: %ld uses\n", (long)((c2 - c1) / TEST_COUNT));
     return NULL;
 }
 
 static void* thr2_run(opal_object_t* obj)
 {
-    int i;
     clock_t c1, c2;
-    opal_mutex_lock(&mutex);
     c1 = clock();
-    for(i=0; i<TEST_COUNT; i++) {
+    opal_mutex_lock(&mutex);
+    while(TEST_COUNT != thr2_count) {
+        thr2_count++;
         opal_condition_signal(&thr1_cond);
         opal_condition_wait(&thr2_cond, &mutex);
-        thr2_count++;
     }
-    c2 = clock();
+
+    // Whoever gets here first needs to alert the other
+    // thread for the last iteration.
+    opal_condition_signal(&thr1_cond);
     opal_mutex_unlock(&mutex);
+
+    c2 = clock();
     fprintf(stderr, "thr2: time per iteration: %ld usec\n", (long)((c2 - c1) / TEST_COUNT));
     return NULL;
 }
 
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
     int rc;
     opal_thread_t* thr1;