SkTaskGroup::batch(fn, args, N)

src/core/SkTaskGroup.cpp

 #include "SkTaskGroup.h"
 
 #include "SkCondVar.h"
 #include "SkRunnable.h"
 #include "SkTDArray.h"
 #include "SkThread.h"
 #include "SkThreadUtils.h"
 
 #if defined(SK_BUILD_FOR_WIN32)
     static inline int num_cores() {
@@ skipping 19 matching lines @@
         gGlobal->add(&CallRunnable, task, pending);
     }
 
     static void Add(void (*fn)(void*), void* arg, int32_t* pending) {
         if (!gGlobal) {
             return fn(arg);
         }
         gGlobal->add(fn, arg, pending);
     }
 
+    static void Batch(void (*fn)(void*), void* args, int N, size_t stride, int32_t* pending) {
+        if (!gGlobal) {
+            for (int i = 0; i < N; i++) { fn((char*)args + i*stride); }
+            return;
+        }
+        gGlobal->batch(fn, args, N, stride, pending);
+    }
+
     static void Wait(int32_t* pending) {
         if (!gGlobal) {  // If we have no threads, the work must already be done.
             SkASSERT(*pending == 0);
             return;
         }
         while (sk_acquire_load(pending) > 0) {  // Pairs with sk_atomic_dec here or in Loop.
             // Lend a hand until our SkTaskGroup of interest is done.
             Work work;
             {
                 AutoLock lock(&gGlobal->fReady);
@@ skipping 54 matching lines @@
     void add(void (*fn)(void*), void* arg, int32_t* pending) {
         Work work = { fn, arg, pending };
         sk_atomic_inc(pending);  // No barrier needed.
         {
             AutoLock lock(&fReady);
             fWork.push(work);
             fReady.signal();
         }
     }
 
+    void batch(void (*fn)(void*), void* arg, int N, size_t stride, int32_t* pending) {
+        sk_atomic_add(pending, N);  // No barrier needed.
+        {
+            AutoLock lock(&fReady);
+            Work* batch = fWork.append(N);
+            for (int i = 0; i < N; i++) {
+                Work work = { fn, (char*)arg + i*stride, pending };
+                batch[i] = work;
+            }
+            fReady.broadcast();
+        }
+    }
+
     static void Loop(void* arg) {
         ThreadPool* pool = (ThreadPool*)arg;
         Work work;
         while (true) {
             {
                 AutoLock lock(&pool->fReady);
                 while (pool->fWork.isEmpty()) {
                     if (pool->fDraining) {
                         return;
                     }
@@ skipping 24 matching lines @@
         ThreadPool::gGlobal = SkNEW_ARGS(ThreadPool, (threads));
     }
 }
 
 SkTaskGroup::Enabler::~Enabler() {
     SkDELETE(ThreadPool::gGlobal);
 }
 
 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::wait()                            { ThreadPool::Wait(&fPending); }
+void SkTaskGroup::batch (void (*fn)(void*), void* args, int N, size_t stride) {
+    ThreadPool::Batch(fn, args, N, stride, &fPending);
+}