Change default to not use pthreads at startup (all calculations on main thread)

native_client_sdk/src/examples/demo/voronoi/threadpool.cc

 // Copyright (c) 2013 The Chromium 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 "threadpool.h"
 
 #include <pthread.h>
 #include <semaphore.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-// TODO(nfullagar): Switch DecCounter to use atomic decrement.
+#include "utils/auto_lock.h"
 
 // Initializes mutex, semaphores and a pool of threads.  If 0 is passed for
 // num_threads, all work will be performed on the dispatch thread.
 ThreadPool::ThreadPool(int num_threads)
     : threads_(NULL), counter_(0), num_threads_(num_threads), exiting_(false),
       user_data_(NULL), user_work_function_(NULL) {
   if (num_threads_ > 0) {
     int status;
-    status = pthread_mutex_init(&mutex_, NULL);
-    if (0 != status) {
-      fprintf(stderr, "Failed to initialize mutex!\n");
-      exit(-1);
-    }
     status = sem_init(&work_sem_, 0, 0);
     if (-1 == status) {
       fprintf(stderr, "Failed to initialize semaphore!\n");
       exit(-1);
     }
     status = sem_init(&done_sem_, 0, 0);
     if (-1 == status) {
       fprintf(stderr, "Failed to initialize semaphore!\n");
       exit(-1);
     }
     threads_ = new pthread_t[num_threads_];
     for (int i = 0; i < num_threads_; i++) {
       status = pthread_create(&threads_[i], NULL, WorkerThreadEntry, this);
       if (0 != status) {
         fprintf(stderr, "Failed to create thread!\n");
         exit(-1);
       }
     }
   }
 }
 
 // Post exit request, wait for all threads to join, and cleanup.
 ThreadPool::~ThreadPool() {
-  if (num_threads_ > 1) {
+  if (num_threads_ > 0) {
     PostExitAndJoinAll();
     delete[] threads_;
     sem_destroy(&done_sem_);
     sem_destroy(&work_sem_);
-    pthread_mutex_destroy(&mutex_);
   }
 }
 
 // Setup work parameters.  This function is called from the dispatch thread,
 // when all worker threads are sleeping.
 void ThreadPool::Setup(int counter, WorkFunction work, void *data) {
   counter_ = counter;
   user_work_function_ = work;
   user_data_ = data;
 }
 
-// Decrement and get the value of the mutex protected counter.  This function
+// Return decremented task counter.  This function
 // can be called from multiple threads at any given time.
 int ThreadPool::DecCounter() {
-  int v;
-  pthread_mutex_lock(&mutex_);
-  {
-    v = --counter_;
-  }
-  pthread_mutex_unlock(&mutex_);
-  return v;
+#if defined(__native_client__)
+  // Use fast atomic sub & fetch.
+  return __sync_sub_and_fetch(&counter_, 1);
+#else
+  // Fallback to a more platform independent pthread mutex via AutoLock.
+  static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+  AutoLock lock(&mutex);
+  return --counter_;
+#endif
 }
 
 // Set exit flag, post and join all the threads in the pool.  This function is
 // called only from the dispatch thread, and only when all worker threads are
 // sleeping.
 void ThreadPool::PostExitAndJoinAll() {
   exiting_ = true;
   // Wake up all the sleeping worker threads.
   for (int i = 0; i < num_threads_; ++i)
     sem_post(&work_sem_);
@@ skipping 53 matching lines @@
 // Dispatch() will invoke the user supplied work function across
 // one or more threads for each task.
 // Note: This function will block until all work has completed.
 void ThreadPool::Dispatch(int num_tasks, WorkFunction work, void* data) {
   if (num_threads_ > 0)
     DispatchMany(num_tasks, work, data);
   else
     DispatchHere(num_tasks, work, data);
 }