SkTaskGroup::batch(fn, args, N)

src/utils/SkTaskGroup.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTaskGroup_DEFINED
 #define SkTaskGroup_DEFINED
 
 #include "SkTypes.h"
 #include "SkRunnable.h"
 
 class SkTaskGroup : SkNoncopyable {
 public:
     // Create one of these in main() to enable SkTaskGroups globally.
     struct Enabler : SkNoncopyable {
         explicit Enabler(int threads = -1);  // Default is system-reported core count.
         ~Enabler();
     };
 
     SkTaskGroup();
     ~SkTaskGroup() { this->wait(); }
 
     // Add a task to this SkTaskGroup.  It will likely run on another thread.
     // Neither add() method takes owership of any of its parameters.
     void add(SkRunnable*);
     void add(void (*fn)(void*), void* arg);
 
+    // Add a batch of N tasks, all calling fn with different arguments.
+    // Equivalent to a loop over add(fn, arg), but with perhaps less synchronization overhead.
+    template <typename T>
+    void batch(void (*fn)(void*), T* args, int N) { this->batch(fn, args, N, sizeof(T)); }

[reed1, 2014/10/29 19:57:30]

1. Slightly odd to me that we don't expose the non-template version, but ok.

2. Can fn be defined to take T* instead of void*, as another convenience (avoid
casting in fn)?

[mtklein, 2014/10/29 20:01:00]

Yeah.  Just seemed like the template version makes it harder to screw up the
stride.  We could expose the raw strided version if you like.
No.  All the functions the threadpool deals with have to have the same type. 
When the thread picks it up, it doesn't know what type to cast the function
pointer or argument pointer to.

+
     // Block until all Tasks previously add()ed to this SkTaskGroup have run.
     // You may safely reuse this SkTaskGroup after wait() returns.
     void wait();
 
 private:
+    void batch(void (*fn)(void*), void* args, int N, size_t stride);
+
     /*atomic*/ int32_t fPending;
 };
 
 #endif//SkTaskGroup_DEFINED