If we swap its arguments, SkTaskGroup::batch() _is_ sk_parallel_for.

Why have two names if we can get away with one?

This kills off sk_parallel_for_thread_count(), which was only used to avoid forcing a deadlock in OncePtrTest on multicore machines in singlethreaded mode... a really niche use case.  Instead just don't explicitly force a race.

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1552093002

Review URL: https://codereview.chromium.org/1552093002

diff --git a/bench/SkGlyphCacheBench.cpp b/bench/SkGlyphCacheBench.cpp
index c99b5728fd305e2d5afbb633b90a92216fcac905..2e0429fce34a3babd0b9ed055b6f58f3f223eca6 100644 (file)
--- a/bench/SkGlyphCacheBench.cpp
+++ b/bench/SkGlyphCacheBench.cpp
@@ -95,7 +95,7 @@ protected:
              sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kItalic)};
 
         for (int work = 0; work < loops; work++) {
-            sk_parallel_for(16, [&](int threadIndex) {
+            SkTaskGroup().batch(16, [&](int threadIndex) {
                 SkPaint paint;
                 paint.setAntiAlias(true);
                 paint.setSubpixelText(true);

diff --git a/dm/DM.cpp b/dm/DM.cpp
index ac37aeb09fd06a9b98a80d673ab4a5abf73b0b22..ace49076ac74427c58486d13e43ea4acf59aeed1 100644 (file)
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -1093,12 +1093,13 @@ int dm_main() {
     }
 
     SkTaskGroup tg;
-    tg.batch([](int i){ run_test(&gThreadedTests[i]); }, gThreadedTests.count());
+    tg.batch(gThreadedTests.count(), [](int i){ run_test(&gThreadedTests[i]); });
     for (int i = 0; i < kNumEnclaves; i++) {
         SkTArray<Task>* currentEnclave = &enclaves[i];
         switch(i) {
             case kAnyThread_Enclave:
-                tg.batch([currentEnclave](int j) { Task::Run(&(*currentEnclave)[j]); }, currentEnclave->count());
+                tg.batch(currentEnclave->count(),
+                         [currentEnclave](int j) { Task::Run(&(*currentEnclave)[j]); });
                 break;
             case kGPU_Enclave:
                 tg.add([currentEnclave](){ run_enclave_and_gpu_tests(currentEnclave); });

diff --git a/samplecode/SamplePathFuzz.cpp b/samplecode/SamplePathFuzz.cpp
index 317833dfe9ec37402ae9778c6d28a3f3fc584ec7..d719826752770c33333f9d6e5d85da97405f4835 100644 (file)
--- a/samplecode/SamplePathFuzz.cpp
+++ b/samplecode/SamplePathFuzz.cpp
@@ -619,7 +619,7 @@ static bool contains_only_moveTo(const SkPath& path) {
 #include "SkTDArray.h"
 
 static void path_fuzz_stroker(SkBitmap* bitmap, int seed) {
-    sk_parallel_for(100, [&](int i) {
+    SkTaskGroup().batch(100, [&](int i) {
         int localSeed = seed + i;
 
         FuzzPath fuzzPath;

diff --git a/src/core/SkMultiPictureDraw.cpp b/src/core/SkMultiPictureDraw.cpp
index 672bd628b7c728220c667d0104bfcd4d183f00d3..57456648581beadbe8bc1c04c63e35a2e795b804 100644 (file)
--- a/src/core/SkMultiPictureDraw.cpp
+++ b/src/core/SkMultiPictureDraw.cpp
@@ -94,7 +94,7 @@ void SkMultiPictureDraw::draw(bool flush) {
         fThreadSafeDrawData[i].draw();
     }
 #else
-    sk_parallel_for(fThreadSafeDrawData.count(), [&](int i) {
+    SkTaskGroup().batch(fThreadSafeDrawData.count(), [&](int i) {
         fThreadSafeDrawData[i].draw();
     });
 #endif

diff --git a/src/core/SkTaskGroup.cpp b/src/core/SkTaskGroup.cpp
index e6b8532bb046e5175f4854bee5c2da147aa105e9..1799256d6fe869a6d1fa58987302ecac739afdae 100644 (file)
--- a/src/core/SkTaskGroup.cpp
+++ b/src/core/SkTaskGroup.cpp
@@ -54,12 +54,12 @@ public:
         gGlobal->add(fn, pending);
     }
 
-    static void Batch(std::function<void(int)> fn, int N, SkAtomic<int32_t>* pending) {
+    static void Batch(int N, std::function<void(int)> fn, SkAtomic<int32_t>* pending) {
         if (!gGlobal) {
             for (int i = 0; i < N; i++) { fn(i); }
             return;
         }
-        gGlobal->batch(fn, N, pending);
+        gGlobal->batch(N, fn, pending);
     }
 
     static void Wait(SkAtomic<int32_t>* pending) {
@@ -142,7 +142,7 @@ private:
         fWorkAvailable.signal(1);
     }
 
-    void batch(std::function<void(int)> fn, int N, SkAtomic<int32_t>* pending) {
+    void batch(int N, std::function<void(int)> fn, SkAtomic<int32_t>* pending) {
         pending->fetch_add(+N, sk_memory_order_relaxed);  // No barrier needed.
         {
             AutoLock lock(&fWorkLock);
@@ -196,7 +196,6 @@ private:
     static ThreadPool* gGlobal;
 
     friend struct SkTaskGroup::Enabler;
-    friend int ::sk_parallel_for_thread_count();
 };
 ThreadPool* ThreadPool::gGlobal = nullptr;
 
@@ -216,13 +215,7 @@ SkTaskGroup::SkTaskGroup() : fPending(0) {}
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(SkRunnable* task)             { ThreadPool::Add(task, &fPending); }
 void SkTaskGroup::add(std::function<void(void)> fn) { ThreadPool::Add(fn, &fPending); }
-void SkTaskGroup::batch (std::function<void(int)> fn, int N) {
-    ThreadPool::Batch(fn, N, &fPending);
+void SkTaskGroup::batch(int N, std::function<void(int)> fn) {
+    ThreadPool::Batch(N, fn, &fPending);
 }
 
-int sk_parallel_for_thread_count() {
-    if (ThreadPool::gGlobal != nullptr) {
-        return ThreadPool::gGlobal->fThreads.count();
-    }
-    return 0;
-}

diff --git a/src/core/SkTaskGroup.h b/src/core/SkTaskGroup.h
index d1daa444945c6ada116c155a5c9c6cba38dc17f8..e6c36651fd50772a67b417e2044447e6c120fcdb 100644 (file)
--- a/src/core/SkTaskGroup.h
+++ b/src/core/SkTaskGroup.h
@@ -34,7 +34,7 @@ public:
     void add(std::function<void(void)> fn);
 
     // Add a batch of N tasks, all calling fn with different arguments.
-    void batch(std::function<void(int)> fn, int N);
+    void batch(int N, std::function<void(int)> fn);
 
     // Block until all Tasks previously add()ed to this SkTaskGroup have run.
     // You may safely reuse this SkTaskGroup after wait() returns.
@@ -47,48 +47,4 @@ private:
 // Returns best estimate of number of CPU cores available to use.
 int sk_num_cores();
 
-int sk_parallel_for_thread_count();
-
-// Call f(i) for i in [0, end).
-template <typename Func>
-void sk_parallel_for(int end, const Func& f) {
-    if (end <= 0) { return; }
-
-    struct Chunk {
-        const Func* f;
-        int start, end;
-    };
-
-    // TODO(mtklein): this chunking strategy could probably use some tuning.
-    int max_chunks  = sk_num_cores() * 2,
-        stride      = (end + max_chunks - 1 ) / max_chunks,
-        nchunks     = (end + stride - 1 ) / stride;
-    SkASSERT(nchunks <= max_chunks);
-
-#if defined(GOOGLE3)
-    // Stack frame size is limited in GOOGLE3.
-    SkAutoSTMalloc<512, Chunk> chunks(nchunks);
-#else
-    // With the chunking strategy above this won't malloc until we have a machine with >512 cores.
-    SkAutoSTMalloc<1024, Chunk> chunks(nchunks);
-#endif
-
-    for (int i = 0; i < nchunks; i++) {
-        Chunk& c = chunks[i];
-        c.f      = &f;
-        c.start  = i * stride;
-        c.end    = SkTMin(c.start + stride, end);
-        SkASSERT(c.start < c.end);  // Nothing will break if start >= end, but it's a wasted chunk.
-    }
-
-    Chunk* chunkBase = chunks.get();
-    auto run_chunk = [chunkBase](int i) {
-        Chunk& c = chunkBase[i];
-        for (int i = c.start; i < c.end; i++) {
-            (*c.f)(i);
-        }
-    };
-    SkTaskGroup().batch(run_chunk, nchunks);
-}
-
 #endif//SkTaskGroup_DEFINED

diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp
index 518a7e241d43ef36578922607075579711dad325..612492d271ab7ca5036c2aa3de16d08fcddf88a6 100644 (file)
--- a/tests/BlendTest.cpp
+++ b/tests/BlendTest.cpp
@@ -98,5 +98,5 @@ DEF_TEST(Blend_premul_begets_premul, r) {
     };
 
     // Parallelism helps speed things up on my desktop from ~725s to ~50s.
-    sk_parallel_for(SkXfermode::kLastMode, test_mode);
+    SkTaskGroup().batch(SkXfermode::kLastMode, test_mode);
 }

diff --git a/tests/OncePtrTest.cpp b/tests/OncePtrTest.cpp
index 103172751a792a756be33692cf5120e814c2da76..d01cee09fe913932de27ce52a017d25821b50582 100644 (file)
--- a/tests/OncePtrTest.cpp
+++ b/tests/OncePtrTest.cpp
@@ -18,14 +18,7 @@ DEF_TEST(OncePtr, r) {
         return new int(5);
     };
 
-    SkAtomic<int> force_a_race(sk_parallel_for_thread_count());
-    if (force_a_race < 1) {
-        return;
-    }
-    sk_parallel_for(sk_num_cores()*4, [&](size_t) {
-        force_a_race.fetch_add(-1);
-        while (force_a_race.load() > 0);
-
+    SkTaskGroup().batch(sk_num_cores()*4, [&](size_t) {
         int* n = once.get(create);
         REPORTER_ASSERT(r, *n == 5);
     });
@@ -39,7 +32,7 @@ DEF_TEST(OnceNoPtr, r) {
     static SkAtomic<int> calls(0);
 
     SkAtomic<int> force_a_race(sk_num_cores());
-    sk_parallel_for(sk_num_cores()*4, [&](size_t) {
+    SkTaskGroup().batch(sk_num_cores()*4, [&](size_t) {
         force_a_race.fetch_add(-1);
         while (force_a_race.load() > 0);
 

diff --git a/tests/OnceTest.cpp b/tests/OnceTest.cpp
index 35c2015166b98e9209ad9cf8fbf4aa858d65815f..3fd569a42aaa40ccae8a8261692395fc3b842bd8 100644 (file)
--- a/tests/OnceTest.cpp
+++ b/tests/OnceTest.cpp
@@ -32,7 +32,7 @@ SK_DECLARE_STATIC_ONCE(mt_once);
 DEF_TEST(SkOnce_Multithreaded, r) {
     int x = 0;
     // Run a bunch of tasks to be the first to add six to x.
-    sk_parallel_for(1021, [&](int) {
+    SkTaskGroup().batch(1021, [&](int) {
         void(*add_six)(int*) = [](int* p) { *p += 6; };
         SkOnce(&mt_once, add_six, &x);
     });

diff --git a/tests/PathOpsSkpClipTest.cpp b/tests/PathOpsSkpClipTest.cpp
index f82d75d036890303dd6a1432d800da2ee02eedff..e70e1c0c663dc76622bd8add3d9c522f9503fb81 100644 (file)
--- a/tests/PathOpsSkpClipTest.cpp
+++ b/tests/PathOpsSkpClipTest.cpp
@@ -307,7 +307,7 @@ TestRunner::~TestRunner() {
 void TestRunner::render() {
     // TODO: this doesn't really need to use SkRunnables any more.
     // We can just write the code to run in the for-loop directly.
-    sk_parallel_for(fRunnables.count(), [&](int i) {
+    SkTaskGroup().batch(fRunnables.count(), [&](int i) {
         fRunnables[i]->run();
     });
 }

diff --git a/tests/PathOpsThreadedCommon.cpp b/tests/PathOpsThreadedCommon.cpp
index 342b56004950aac00b558d0fa0007cdaf92c1f06..c9a06f0a52bf792cbaa30d05c88a03dc1c7da3da 100644 (file)
--- a/tests/PathOpsThreadedCommon.cpp
+++ b/tests/PathOpsThreadedCommon.cpp
@@ -16,7 +16,7 @@ PathOpsThreadedTestRunner::~PathOpsThreadedTestRunner() {
 }
 
 void PathOpsThreadedTestRunner::render() {
-    sk_parallel_for(fRunnables.count(), [&](int i) {
+    SkTaskGroup().batch(fRunnables.count(), [&](int i) {
         fRunnables[i]->run();
     });
 }

diff --git a/tests/SkSharedMutexTest.cpp b/tests/SkSharedMutexTest.cpp
index bdf072b6b75cc471f5f8692f49292d39464db1d8..845889174b44c673ac93bd812cdcae08ac18283c 100644 (file)
--- a/tests/SkSharedMutexTest.cpp
+++ b/tests/SkSharedMutexTest.cpp
@@ -28,7 +28,7 @@ DEF_TEST(SkSharedMutexMultiThreaded, r) {
     for (int i = 0; i < kSharedSize; ++i) {
         shared[i] = 0;
     }
-    sk_parallel_for(8, [&](int threadIndex) {
+    SkTaskGroup().batch(8, [&](int threadIndex) {
         if (threadIndex % 4 != 0) {
             for (int c = 0; c < 100000; ++c) {
                 sm.acquireShared();

diff --git a/tests/SkpSkGrTest.cpp b/tests/SkpSkGrTest.cpp
index 98c54e032cddb9e6941c846d8a513bfe43819b47..241395a7533c09e80d76541295e6b4d11c5df6b6 100644 (file)
--- a/tests/SkpSkGrTest.cpp
+++ b/tests/SkpSkGrTest.cpp
@@ -171,7 +171,7 @@ SkpSkGrThreadedTestRunner::~SkpSkGrThreadedTestRunner() {
 void SkpSkGrThreadedTestRunner::render() {
     // TODO: we don't really need to be using SkRunnables here anymore.
     // We can just write the code we'd run right in the for loop.
-    sk_parallel_for(fRunnables.count(), [&](int i) {
+    SkTaskGroup().batch(fRunnables.count(), [&](int i) {
         fRunnables[i]->run();
     });
 }