atomic_ops_test: Simplify by using joinable threads

tests/unittests/shared/platform/atomic_ops_test.c

 /* Copyright (c) 2011 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <stdio.h>
 #include "native_client/src/include/atomic_ops.h"
 #include "native_client/src/shared/platform/nacl_threads.h"
 #include "native_client/src/shared/platform/nacl_sync_checked.h"
 #include "native_client/src/shared/platform/nacl_sync.h"
 
 #define THREAD_STACK_SIZE  (128*1024)
 
 int32_t gIncrementsPerThread = 1000;
 int32_t gNumThreads;
 
 struct NaClMutex gMutex;
-struct NaClCondVar gFinishedCv;
-int32_t gFinishedCount = 0;
 
 
 /* For atomic counter test */
 Atomic32 gCounter = 0;
 
 static void IncrementTest() {
   /* Increment the counter, gIncrementsPerThread times,
    * with the values 1...gIncrementsPerThread
    */
   Atomic32 i;
@@ skipping 53 matching lines @@
     IncrementTest();
     DecrementTest();
   } else {
     DecrementTest();
     IncrementTest();
   }
 
   ExchangeTest(tid);
 
   CompareAndSwapTest(tid);
-
-  /* Signal that we're finished */
-  NaClXMutexLock(&gMutex);
-  gFinishedCount++;
-  NaClXCondVarSignal(&gFinishedCv);
-  NaClXMutexUnlock(&gMutex);
-
-  NaClThreadExit(0);
 }
 
 int main(int argc, const char *argv[]) {
   struct NaClThread *threads;
   int rv;
   int32_t tid;
   int32_t tmp;
 
   if (argc != 2) {
     fprintf(stderr, "Usage: %s <NumThreads>\n", argv[0]);
     exit(EXIT_FAILURE);
   }
 
   gNumThreads = strtol(argv[1], NULL, 10);
 
   threads = (struct NaClThread*)malloc(gNumThreads*sizeof(struct NaClThread));
   if (threads == NULL) {
     fprintf(stderr, "malloc returned NULL\n");
     exit(EXIT_FAILURE);
   }
 
   if (!NaClMutexCtor(&gMutex)) {
     fprintf(stderr, "NaClMutexCtor failed\n");
     exit(EXIT_FAILURE);
   }
 
-  if (!NaClCondVarCtor(&gFinishedCv)) {
-    fprintf(stderr, "NaClCondVarCtor failed\n");
-    exit(EXIT_FAILURE);
-  }
   NaClXMutexLock(&gMutex);
 
   for (tid = 1; tid <= gNumThreads; ++tid) {
     fprintf(stderr, "Creating thread %d\n", (int)tid);
 
-    rv = NaClThreadCtor(&threads[tid-1],
-                        ThreadMain,
-                        (void*) (intptr_t) tid,
-                        THREAD_STACK_SIZE);
+    rv = NaClThreadCreateJoinable(&threads[tid-1],
+                                  ThreadMain,
+                                  (void*) (intptr_t) tid,
+                                  THREAD_STACK_SIZE);
     if (!rv) {
       fprintf(stderr, "NaClThreadCtor failed\n");
       exit(EXIT_FAILURE);
     }
   }
 
-  while (gFinishedCount != gNumThreads) {
-    /* This releases the mutex, so the tests begin */
-    NaClXCondVarWait(&gFinishedCv, &gMutex);
+  NaClXMutexUnlock(&gMutex);
+
+  for (tid = 1; tid <= gNumThreads; ++tid) {
+    NaClThreadJoin(&threads[tid-1]);
   }
-  NaClXMutexUnlock(&gMutex);
 
   /* Check the results */
   tmp = gIncrementsPerThread * gNumThreads;
   if (gCounter != tmp) {
     fprintf(stderr, "ERROR: gCounter is wrong. Expected %d, got %d\n",
            (int)tmp, (int)gCounter);
     exit(EXIT_FAILURE);
   }
 
   tmp = gNumThreads*(gNumThreads+1)/2;
   if (gExchange + gExchangeSum != tmp) {
     fprintf(stderr,
             "ERROR: gExchange+gExchangeSum is wrong. Expected %d, got %d\n",
             (int)tmp, (int)(gExchange + gExchangeSum));
     exit(EXIT_FAILURE);
   }
 
   if (gSwap != gNumThreads+1) {
     fprintf(stderr, "ERROR: gSwap is wrong. Expected %d, got %d\n",
             (int)(gNumThreads+1), (int)gSwap);
     exit(EXIT_FAILURE);
   }
 
   fprintf(stderr, "PASSED\n");
-  NaClCondVarDtor(&gFinishedCv);
   NaClMutexDtor(&gMutex);
   free(threads);
   return 0;
 }