After profiling I found that a lot of extra time was spent in Finish while waiting for the atomic_int to

be updated to signal work was done. Thus I changed to using promises again, this time using a move_on_copy template to pass in the promise.
This causes a dramatic performance increase, especially for the LFThreadPool. A few initial tests have it running the fastest.

Author: Chris Sullivan

include/ThreadPoolBase.hh

@@ -8,6 +8,7 @@
 #include <vector>
 #include <utility>
 #include <future>
+#include "move_on_copy.hh"
 
 using namespace std;
 
@@ -22,31 +23,34 @@ public:
         virtual void Worker() = 0;
         virtual void CleanUp() { m_stopWorkers = true; }
         void JoinAll();
-        void Finish();
 
         template <typename T, typename... Params>
         void ParallelFor(uint32_t begin, uint32_t end, uint32_t n_tasks, T SerialFunction, Params&&... params) {
 
                 n_tasks = (n_tasks >= m_workers.size()) ? n_tasks : m_workers.size();
-                m_tasksRemaining = n_tasks;
+                std::future<void> futures[n_tasks];
                 int chunk = (end - begin) / n_tasks;
                 for (auto i = 0u; i < n_tasks; ++i) {
-                        AddTask([=]{
+                        std::promise<void> promise;
+                        futures[i] = promise.get_future();
+                        auto move_promise = make_move_on_copy(move(promise));
+                        AddTask([=] () mutable {
                                         uint32_t threadstart = begin + i*chunk;
                                         uint32_t threadstop = (i == n_tasks - 1) ? end : threadstart + chunk;
                                         for (uint32_t it = threadstart; it < threadstop; ++it) {
                                                 SerialFunction(it, params...);
                                         }
-                                        m_tasksRemaining--;
+                                        move_promise.value().set_value();
                                 });
                 }
-                Finish();
+                for (auto i = 0u; i<n_tasks; i++) {
+                        futures[i].get();
+                }
         }
 
 protected:
         // threads and task queue
         vector<thread> m_workers;
-        atomic<int> m_tasksRemaining;
         bool m_stopWorkers;
 };
 

src/ThreadPoolBase.cc

@@ -3,6 +3,3 @@
 void ThreadPoolBase::JoinAll() {
     for (auto& worker : m_workers) { worker.join(); }
 }
-void ThreadPoolBase::Finish() {
-    while (m_tasksRemaining > 0) {}
-}