Add sk_parallel_for()

src/core/SkTaskGroup.cpp

+/*
+ * Copyright 2014 Google Inc.

[caryclark, 2015/06/16 19:04:25]

2015? (Not sure whether its appropriate to predate old code that omitted its
copyright header)

[mtklein, 2015/06/16 19:16:21]

I have no idea.  I did write it in 2014.

+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
 #include "SkTaskGroup.h"
 
 #include "SkCondVar.h"
+#include "SkOnce.h"
 #include "SkRunnable.h"
 #include "SkTDArray.h"
 #include "SkThread.h"
 #include "SkThreadUtils.h"
 
 #if defined(SK_BUILD_FOR_WIN32)
-    static inline int num_cores() {
+    static void query_num_cores(int* num_cores) {
         SYSTEM_INFO sysinfo;
         GetSystemInfo(&sysinfo);
-        return sysinfo.dwNumberOfProcessors;
+        *num_cores = sysinfo.dwNumberOfProcessors;
     }
 #else
     #include <unistd.h>
-    static inline int num_cores() {
-        return (int) sysconf(_SC_NPROCESSORS_ONLN);
+    static void query_num_cores(int* num_cores) {
+        *num_cores = (int)sysconf(_SC_NPROCESSORS_ONLN);
     }
 #endif
 
+// We cache sk_num_cores() so we only query the OS once.
+SK_DECLARE_STATIC_ONCE(g_query_num_cores_once);
+int sk_num_cores() {
+    static int num_cores = 0;
+    SkOnce(&g_query_num_cores_once, query_num_cores, &num_cores);
+    SkASSERT(num_cores > 0);
+    return num_cores;
+}
+
 namespace {
 
 class ThreadPool : SkNoncopyable {
 public:
     static void Add(SkRunnable* task, int32_t* pending) {
         if (!gGlobal) {  // If we have no threads, run synchronously.
             return task->run();
         }
         gGlobal->add(&CallRunnable, task, pending);
     }
@@ skipping 48 matching lines @@
     static void CallRunnable(void* arg) { static_cast<SkRunnable*>(arg)->run(); }
 
     struct Work {
         void (*fn)(void*);  // A function to call,
         void* arg;          // its argument,
         int32_t* pending;   // then sk_atomic_dec(pending) afterwards.
     };
 
     explicit ThreadPool(int threads) : fDraining(false) {
         if (threads == -1) {
-            threads = num_cores();
+            threads = sk_num_cores();
         }
         for (int i = 0; i < threads; i++) {
             fThreads.push(SkNEW_ARGS(SkThread, (&ThreadPool::Loop, this)));
             fThreads.top()->start();
         }
     }
 
     ~ThreadPool() {
         SkASSERT(fWork.isEmpty());  // All SkTaskGroups should be destroyed by now.
         {
@@ skipping 75 matching lines @@
 
 SkTaskGroup::SkTaskGroup() : fPending(0) {}
 
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(SkRunnable* task)             { ThreadPool::Add(task, &fPending); }
 void SkTaskGroup::add(void (*fn)(void*), void* arg) { ThreadPool::Add(fn, arg, &fPending); }
 void SkTaskGroup::batch (void (*fn)(void*), void* args, int N, size_t stride) {
     ThreadPool::Batch(fn, args, N, stride, &fPending);
 }