Updated to v3.4.0

BS_thread_pool.hpp

@@ -3,14 +3,14 @@
 /**
  * @file BS_thread_pool.hpp
  * @author Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)
- * @version 3.2.0
- * @date 2022-07-28
- * @copyright Copyright (c) 2022 Barak Shoshany. Licensed under the MIT license. If you found this project useful, please consider starring it on GitHub! If you use this library in software of any kind, please provide a link to the GitHub repository https://github.com/bshoshany/thread-pool in the source code and documentation. If you use this library in published research, please cite it as follows: Barak Shoshany, "A C++17 Thread Pool for High-Performance Scientific Computing", doi:10.5281/zenodo.4742687, arXiv:2105.00613 (May 2021)
+ * @version 3.4.0
+ * @date 2023-05-12
+ * @copyright Copyright (c) 2023 Barak Shoshany. Licensed under the MIT license. If you found this project useful, please consider starring it on GitHub! If you use this library in software of any kind, please provide a link to the GitHub repository https://github.com/bshoshany/thread-pool in the source code and documentation. If you use this library in published research, please cite it as follows: Barak Shoshany, "A C++17 Thread Pool for High-Performance Scientific Computing", doi:10.5281/zenodo.4742687, arXiv:2105.00613 (May 2021)
  *
  * @brief BS::thread_pool: a fast, lightweight, and easy-to-use C++17 thread pool library. This header file contains the entire library, including the main BS::thread_pool class and the helper classes BS::multi_future, BS::blocks, BS:synced_stream, and BS::timer.
  */
 
-#define BS_THREAD_POOL_VERSION "v3.2.0 (2022-07-28)"
+#define BS_THREAD_POOL_VERSION "v3.4.0 (2023-05-12)"
 
 #include <atomic>             // std::atomic
 #include <chrono>             // std::chrono
@@ -34,12 +34,6 @@ namespace BS
  */
 using concurrency_t = std::invoke_result_t<decltype(std::thread::hardware_concurrency)>;
 
-/**
- * @brief Explicit casts of the flushing stream manipulators, to enable using them with synced_stream, e.g. sync_out.print(BS::flush).
- */
-std::ostream& (&endl)(std::ostream&) = static_cast<std::ostream& (&)(std::ostream&)>(std::endl);
-std::ostream& (&flush)(std::ostream&) = static_cast<std::ostream& (&)(std::ostream&)>(std::flush);
-
 // ============================================================================================= //
 //                                    Begin class multi_future                                   //
 
@@ -57,7 +51,7 @@ public:
      *
      * @param num_futures_ The desired number of futures to store.
      */
-    multi_future(const size_t num_futures_ = 0) : f(num_futures_) {}
+    multi_future(const size_t num_futures_ = 0) : futures(num_futures_) {}
 
     /**
      * @brief Get the results from all the futures stored in this multi_future object, rethrowing any stored exceptions.
@@ -68,32 +62,64 @@ public:
     {
         if constexpr (std::is_void_v<T>)
         {
-            for (size_t i = 0; i < f.size(); ++i)
-                f[i].get();
+            for (size_t i = 0; i < futures.size(); ++i)
+                futures[i].get();
             return;
         }
         else
         {
-            std::vector<T> results(f.size());
-            for (size_t i = 0; i < f.size(); ++i)
-                results[i] = f[i].get();
+            std::vector<T> results(futures.size());
+            for (size_t i = 0; i < futures.size(); ++i)
+                results[i] = futures[i].get();
             return results;
         }
     }
 
+    /**
+     * @brief Get a reference to one of the futures stored in this multi_future object.
+     *
+     * @param i The index of the desired future.
+     * @return The future.
+     */
+    [[nodiscard]] std::future<T>& operator[](const size_t i)
+    {
+        return futures[i];
+    }
+
+    /**
+     * @brief Append a future to this multi_future object.
+     *
+     * @param future The future to append.
+     */
+    void push_back(std::future<T> future)
+    {
+        futures.push_back(std::move(future));
+    }
+
+    /**
+     * @brief Get the number of futures stored in this multi_future object.
+     *
+     * @return The number of futures.
+     */
+    [[nodiscard]] size_t size() const
+    {
+        return futures.size();
+    }
+
     /**
      * @brief Wait for all the futures stored in this multi_future object.
      */
     void wait() const
     {
-        for (size_t i = 0; i < f.size(); ++i)
-            f[i].wait();
+        for (size_t i = 0; i < futures.size(); ++i)
+            futures[i].wait();
     }
 
+private:
     /**
      * @brief A vector to store the futures.
      */
-    std::vector<std::future<T>> f;
+    std::vector<std::future<T>> futures;
 };
 
 //                                     End class multi_future                                    //
@@ -229,7 +255,7 @@ public:
     }
 
     /**
-     * @brief Destruct the thread pool. Waits for all tasks to complete, then destroys all threads. Note that if the variable paused is set to true, then any tasks still in the queue will never be executed.
+     * @brief Destruct the thread pool. Waits for all tasks to complete, then destroys all threads. Note that if the pool is paused, then any tasks still in the queue will never be executed.
      */
     ~thread_pool()
     {
@@ -283,6 +309,16 @@ public:
         return thread_count;
     }
 
+    /**
+     * @brief Check whether the pool is currently paused.
+     *
+     * @return true if the pool is paused, false if it is not paused.
+     */
+    [[nodiscard]] bool is_paused() const
+    {
+        return paused;
+    }
+
     /**
      * @brief Parallelize a loop by automatically splitting it into blocks and submitting each block separately to the queue. Returns a multi_future object that contains the futures for all of the blocks.
      *
@@ -305,7 +341,7 @@ public:
         {
             multi_future<R> mf(blks.get_num_blocks());
             for (size_t i = 0; i < blks.get_num_blocks(); ++i)
-                mf.f[i] = submit(std::forward<F>(loop), blks.start(i), blks.end(i));
+                mf[i] = submit(std::forward<F>(loop), blks.start(i), blks.end(i));
             return mf;
         }
         else
@@ -331,6 +367,14 @@ public:
         return parallelize_loop(0, index_after_last, std::forward<F>(loop), num_blocks);
     }
 
+    /**
+     * @brief Pause the pool. The workers will temporarily stop retrieving new tasks out of the queue, although any tasks already executed will keep running until they are finished.
+     */
+    void pause()
+    {
+        paused = true;
+    }
+
     /**
      * @brief Parallelize a loop by automatically splitting it into blocks and submitting each block separately to the queue. Does not return a multi_future, so the user must use wait_for_tasks() or some other method to ensure that the loop finishes executing, otherwise bad things will happen.
      *
@@ -384,8 +428,8 @@ public:
         {
             const std::scoped_lock tasks_lock(tasks_mutex);
             tasks.push(task_function);
+            ++tasks_total;
         }
-        ++tasks_total;
         task_available_cv.notify_one();
     }
 
@@ -450,25 +494,71 @@ public:
         return task_promise->get_future();
     }
 
+    /**
+     * @brief Unpause the pool. The workers will resume retrieving new tasks out of the queue.
+     */
+    void unpause()
+    {
+        paused = false;
+    }
+
     /**
      * @brief Wait for tasks to be completed. Normally, this function waits for all tasks, both those that are currently running in the threads and those that are still waiting in the queue. However, if the pool is paused, this function only waits for the currently running tasks (otherwise it would wait forever). Note: To wait for just one specific task, use submit() instead, and call the wait() member function of the generated future.
      */
     void wait_for_tasks()
     {
-        waiting = true;
-        std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
-        task_done_cv.wait(tasks_lock, [this] { return (tasks_total == (paused ? tasks.size() : 0)); });
-        waiting = false;
+        if (!waiting)
+        {
+            waiting = true;
+            std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
+            task_done_cv.wait(tasks_lock, [this] { return (tasks_total == (paused ? tasks.size() : 0)); });
+            waiting = false;
+        }
     }
 
-    // ===========
-    // Public data
-    // ===========
+    /**
+     * @brief Wait for tasks to be completed, but stop waiting after the specified duration has passed.
+     *
+     * @tparam R An arithmetic type representing the number of ticks to wait.
+     * @tparam P An std::ratio representing the length of each tick in seconds.
+     * @param duration The time duration to wait.
+     * @return true if finished waiting before the duration expired, false if timed out or the pool is already waiting. In other words, returns false if and only if tasks are still running.
+     */
+    template <typename R, typename P>
+    bool wait_for_tasks_duration(const std::chrono::duration<R, P>& duration)
+    {
+        if (!waiting)
+        {
+            waiting = true;
+            std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
+            const bool status = task_done_cv.wait_for(tasks_lock, duration, [this] { return (tasks_total == (paused ? tasks.size() : 0)); });
+            waiting = false;
+            return status;
+        }
+        return false;
+    }
 
     /**
-     * @brief An atomic variable indicating whether the workers should pause. When set to true, the workers temporarily stop retrieving new tasks out of the queue, although any tasks already executed will keep running until they are finished. Set to false again to resume retrieving tasks.
+     * @brief Wait for tasks to be completed, but stop waiting after the specified time point has been reached.
+     *
+     * @tparam C The type of the clock used to measure time.
+     * @tparam D An std::chrono::duration type used to indicate the time point.
+     * @param timeout_time The time point at which to stop waiting.
+     * @return true if finished waiting before the time point was reached, false if timed out or the pool is already waiting. In other words, returns false if and only if tasks are still running.
      */
-    std::atomic<bool> paused = false;
+    template <typename C, typename D>
+    bool wait_for_tasks_until(const std::chrono::time_point<C, D>& timeout_time)
+    {
+        if (!waiting)
+        {
+            waiting = true;
+            std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
+            const bool status = task_done_cv.wait_until(tasks_lock, timeout_time, [this] { return (tasks_total == (paused ? tasks.size() : 0)); });
+            waiting = false;
+            return status;
+        }
+        return false;
+    }
 
 private:
     // ========================
@@ -493,7 +583,10 @@ private:
     void destroy_threads()
     {
         running = false;
-        task_available_cv.notify_all();
+        {
+            const std::scoped_lock tasks_lock(tasks_mutex);
+            task_available_cv.notify_all();
+        }
         for (concurrency_t i = 0; i < thread_count; ++i)
         {
             threads[i].join();
@@ -547,6 +640,11 @@ private:
     // Private data
     // ============
 
+    /**
+     * @brief An atomic variable indicating whether the workers should pause. When set to true, the workers temporarily stop retrieving new tasks out of the queue, although any tasks already executed will keep running until they are finished. When set to false again, the workers resume retrieving tasks.
+     */
+    std::atomic<bool> paused = false;
+
     /**
      * @brief An atomic variable indicating to the workers to keep running. When set to false, the workers permanently stop working.
      */
@@ -637,6 +735,16 @@ public:
         print(std::forward<T>(items)..., '\n');
     }
 
+    /**
+     * @brief A stream manipulator to pass to a synced_stream (an explicit cast of std::endl). Prints a newline character to the stream, and then flushes it. Should only be used if flushing is desired, otherwise '\n' should be used instead.
+     */
+    inline static std::ostream& (&endl)(std::ostream&) = static_cast<std::ostream& (&)(std::ostream&)>(std::endl);
+
+    /**
+     * @brief A stream manipulator to pass to a synced_stream (an explicit cast of std::flush). Used to flush the stream.
+     */
+    inline static std::ostream& (&flush)(std::ostream&) = static_cast<std::ostream& (&)(std::ostream&)>(std::flush);
+
 private:
     /**
      * @brief The output stream to print to.

BS_thread_pool_light.hpp

@@ -0,0 +1,331 @@
+#pragma once
+
+/**
+ * @file BS_thread_pool_light.hpp
+ * @author Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)
+ * @version 3.4.0
+ * @date 2023-05-12
+ * @copyright Copyright (c) 2023 Barak Shoshany. Licensed under the MIT license. If you found this project useful, please consider starring it on GitHub! If you use this library in software of any kind, please provide a link to the GitHub repository https://github.com/bshoshany/thread-pool in the source code and documentation. If you use this library in published research, please cite it as follows: Barak Shoshany, "A C++17 Thread Pool for High-Performance Scientific Computing", doi:10.5281/zenodo.4742687, arXiv:2105.00613 (May 2021)
+ *
+ * @brief BS::thread_pool_light: a fast, lightweight, and easy-to-use C++17 thread pool library. This header file contains a light version of the main library, for use when advanced features are not needed.
+ */
+
+#define BS_THREAD_POOL_LIGHT_VERSION "v3.4.0 (2023-05-12)"
+
+#include <atomic>             // std::atomic
+#include <condition_variable> // std::condition_variable
+#include <exception>          // std::current_exception
+#include <functional>         // std::bind, std::function, std::invoke
+#include <future>             // std::future, std::promise
+#include <memory>             // std::make_shared, std::make_unique, std::shared_ptr, std::unique_ptr
+#include <mutex>              // std::mutex, std::scoped_lock, std::unique_lock
+#include <queue>              // std::queue
+#include <thread>             // std::thread
+#include <type_traits>        // std::common_type_t, std::decay_t, std::invoke_result_t, std::is_void_v
+#include <utility>            // std::forward, std::move, std::swap
+
+namespace BS
+{
+/**
+ * @brief A convenient shorthand for the type of std::thread::hardware_concurrency(). Should evaluate to unsigned int.
+ */
+using concurrency_t = std::invoke_result_t<decltype(std::thread::hardware_concurrency)>;
+
+/**
+ * @brief A fast, lightweight, and easy-to-use C++17 thread pool class. This is a lighter version of the main thread pool class.
+ */
+class [[nodiscard]] thread_pool_light
+{
+public:
+    // ============================
+    // Constructors and destructors
+    // ============================
+
+    /**
+     * @brief Construct a new thread pool.
+     *
+     * @param thread_count_ The number of threads to use. The default value is the total number of hardware threads available, as reported by the implementation. This is usually determined by the number of cores in the CPU. If a core is hyperthreaded, it will count as two threads.
+     */
+    thread_pool_light(const concurrency_t thread_count_ = 0) : thread_count(determine_thread_count(thread_count_)), threads(std::make_unique<std::thread[]>(determine_thread_count(thread_count_)))
+    {
+        create_threads();
+    }
+
+    /**
+     * @brief Destruct the thread pool. Waits for all tasks to complete, then destroys all threads.
+     */
+    ~thread_pool_light()
+    {
+        wait_for_tasks();
+        destroy_threads();
+    }
+
+    // =======================
+    // Public member functions
+    // =======================
+
+    /**
+     * @brief Get the number of threads in the pool.
+     *
+     * @return The number of threads.
+     */
+    [[nodiscard]] concurrency_t get_thread_count() const
+    {
+        return thread_count;
+    }
+
+    /**
+     * @brief Parallelize a loop by automatically splitting it into blocks and submitting each block separately to the queue. The user must use wait_for_tasks() or some other method to ensure that the loop finishes executing, otherwise bad things will happen.
+     *
+     * @tparam F The type of the function to loop through.
+     * @tparam T1 The type of the first index in the loop. Should be a signed or unsigned integer.
+     * @tparam T2 The type of the index after the last index in the loop. Should be a signed or unsigned integer. If T1 is not the same as T2, a common type will be automatically inferred.
+     * @tparam T The common type of T1 and T2.
+     * @param first_index The first index in the loop.
+     * @param index_after_last The index after the last index in the loop. The loop will iterate from first_index to (index_after_last - 1) inclusive. In other words, it will be equivalent to "for (T i = first_index; i < index_after_last; ++i)". Note that if index_after_last == first_index, no blocks will be submitted.
+     * @param loop The function to loop through. Will be called once per block. Should take exactly two arguments: the first index in the block and the index after the last index in the block. loop(start, end) should typically involve a loop of the form "for (T i = start; i < end; ++i)".
+     * @param num_blocks The maximum number of blocks to split the loop into. The default is to use the number of threads in the pool.
+     */
+    template <typename F, typename T1, typename T2, typename T = std::common_type_t<T1, T2>>
+    void push_loop(T1 first_index_, T2 index_after_last_, F&& loop, size_t num_blocks = 0)
+    {
+        T first_index = static_cast<T>(first_index_);
+        T index_after_last = static_cast<T>(index_after_last_);
+        if (num_blocks == 0)
+            num_blocks = thread_count;
+        if (index_after_last < first_index)
+            std::swap(index_after_last, first_index);
+        size_t total_size = static_cast<size_t>(index_after_last - first_index);
+        size_t block_size = static_cast<size_t>(total_size / num_blocks);
+        if (block_size == 0)
+        {
+            block_size = 1;
+            num_blocks = (total_size > 1) ? total_size : 1;
+        }
+        if (total_size > 0)
+        {
+            for (size_t i = 0; i < num_blocks; ++i)
+                push_task(std::forward<F>(loop), static_cast<T>(i * block_size) + first_index, (i == num_blocks - 1) ? index_after_last : (static_cast<T>((i + 1) * block_size) + first_index));
+        }
+    }
+
+    /**
+     * @brief Parallelize a loop by automatically splitting it into blocks and submitting each block separately to the queue. The user must use wait_for_tasks() or some other method to ensure that the loop finishes executing, otherwise bad things will happen. This overload is used for the special case where the first index is 0.
+     *
+     * @tparam F The type of the function to loop through.
+     * @tparam T The type of the loop indices. Should be a signed or unsigned integer.
+     * @param index_after_last The index after the last index in the loop. The loop will iterate from 0 to (index_after_last - 1) inclusive. In other words, it will be equivalent to "for (T i = 0; i < index_after_last; ++i)". Note that if index_after_last == 0, no blocks will be submitted.
+     * @param loop The function to loop through. Will be called once per block. Should take exactly two arguments: the first index in the block and the index after the last index in the block. loop(start, end) should typically involve a loop of the form "for (T i = start; i < end; ++i)".
+     * @param num_blocks The maximum number of blocks to split the loop into. The default is to use the number of threads in the pool.
+     */
+    template <typename F, typename T>
+    void push_loop(const T index_after_last, F&& loop, const size_t num_blocks = 0)
+    {
+        push_loop(0, index_after_last, std::forward<F>(loop), num_blocks);
+    }
+
+    /**
+     * @brief Push a function with zero or more arguments, but no return value, into the task queue. Does not return a future, so the user must use wait_for_tasks() or some other method to ensure that the task finishes executing, otherwise bad things will happen.
+     *
+     * @tparam F The type of the function.
+     * @tparam A The types of the arguments.
+     * @param task The function to push.
+     * @param args The zero or more arguments to pass to the function. Note that if the task is a class member function, the first argument must be a pointer to the object, i.e. &object (or this), followed by the actual arguments.
+     */
+    template <typename F, typename... A>
+    void push_task(F&& task, A&&... args)
+    {
+        std::function<void()> task_function = std::bind(std::forward<F>(task), std::forward<A>(args)...);
+        {
+            const std::scoped_lock tasks_lock(tasks_mutex);
+            tasks.push(task_function);
+            ++tasks_total;
+        }
+        task_available_cv.notify_one();
+    }
+
+    /**
+     * @brief Submit a function with zero or more arguments into the task queue. If the function has a return value, get a future for the eventual returned value. If the function has no return value, get an std::future<void> which can be used to wait until the task finishes.
+     *
+     * @tparam F The type of the function.
+     * @tparam A The types of the zero or more arguments to pass to the function.
+     * @tparam R The return type of the function (can be void).
+     * @param task The function to submit.
+     * @param args The zero or more arguments to pass to the function. Note that if the task is a class member function, the first argument must be a pointer to the object, i.e. &object (or this), followed by the actual arguments.
+     * @return A future to be used later to wait for the function to finish executing and/or obtain its returned value if it has one.
+     */
+    template <typename F, typename... A, typename R = std::invoke_result_t<std::decay_t<F>, std::decay_t<A>...>>
+    [[nodiscard]] std::future<R> submit(F&& task, A&&... args)
+    {
+        std::function<R()> task_function = std::bind(std::forward<F>(task), std::forward<A>(args)...);
+        std::shared_ptr<std::promise<R>> task_promise = std::make_shared<std::promise<R>>();
+        push_task(
+            [task_function, task_promise]
+            {
+                try
+                {
+                    if constexpr (std::is_void_v<R>)
+                    {
+                        std::invoke(task_function);
+                        task_promise->set_value();
+                    }
+                    else
+                    {
+                        task_promise->set_value(std::invoke(task_function));
+                    }
+                }
+                catch (...)
+                {
+                    try
+                    {
+                        task_promise->set_exception(std::current_exception());
+                    }
+                    catch (...)
+                    {
+                    }
+                }
+            });
+        return task_promise->get_future();
+    }
+
+    /**
+     * @brief Wait for tasks to be completed. Normally, this function waits for all tasks, both those that are currently running in the threads and those that are still waiting in the queue. Note: To wait for just one specific task, use submit() instead, and call the wait() member function of the generated future.
+     */
+    void wait_for_tasks()
+    {
+        if (!waiting)
+        {
+            waiting = true;
+            std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
+            task_done_cv.wait(tasks_lock, [this] { return (tasks_total == 0); });
+            waiting = false;
+        }
+    }
+
+private:
+    // ========================
+    // Private member functions
+    // ========================
+
+    /**
+     * @brief Create the threads in the pool and assign a worker to each thread.
+     */
+    void create_threads()
+    {
+        running = true;
+        for (concurrency_t i = 0; i < thread_count; ++i)
+        {
+            threads[i] = std::thread(&thread_pool_light::worker, this);
+        }
+    }
+
+    /**
+     * @brief Destroy the threads in the pool.
+     */
+    void destroy_threads()
+    {
+        running = false;
+        {
+            const std::scoped_lock tasks_lock(tasks_mutex);
+            task_available_cv.notify_all();
+        }
+        for (concurrency_t i = 0; i < thread_count; ++i)
+        {
+            threads[i].join();
+        }
+    }
+
+    /**
+     * @brief Determine how many threads the pool should have, based on the parameter passed to the constructor.
+     *
+     * @param thread_count_ The parameter passed to the constructor. If the parameter is a positive number, then the pool will be created with this number of threads. If the parameter is non-positive, or a parameter was not supplied (in which case it will have the default value of 0), then the pool will be created with the total number of hardware threads available, as obtained from std::thread::hardware_concurrency(). If the latter returns a non-positive number for some reason, then the pool will be created with just one thread.
+     * @return The number of threads to use for constructing the pool.
+     */
+    [[nodiscard]] concurrency_t determine_thread_count(const concurrency_t thread_count_)
+    {
+        if (thread_count_ > 0)
+            return thread_count_;
+        else
+        {
+            if (std::thread::hardware_concurrency() > 0)
+                return std::thread::hardware_concurrency();
+            else
+                return 1;
+        }
+    }
+
+    /**
+     * @brief A worker function to be assigned to each thread in the pool. Waits until it is notified by push_task() that a task is available, and then retrieves the task from the queue and executes it. Once the task finishes, the worker notifies wait_for_tasks() in case it is waiting.
+     */
+    void worker()
+    {
+        while (running)
+        {
+            std::function<void()> task;
+            std::unique_lock<std::mutex> tasks_lock(tasks_mutex);
+            task_available_cv.wait(tasks_lock, [this] { return !tasks.empty() || !running; });
+            if (running)
+            {
+                task = std::move(tasks.front());
+                tasks.pop();
+                tasks_lock.unlock();
+                task();
+                tasks_lock.lock();
+                --tasks_total;
+                if (waiting)
+                    task_done_cv.notify_one();
+            }
+        }
+    }
+
+    // ============
+    // Private data
+    // ============
+
+    /**
+     * @brief An atomic variable indicating to the workers to keep running. When set to false, the workers permanently stop working.
+     */
+    std::atomic<bool> running = false;
+
+    /**
+     * @brief A condition variable used to notify worker() that a new task has become available.
+     */
+    std::condition_variable task_available_cv = {};
+
+    /**
+     * @brief A condition variable used to notify wait_for_tasks() that a tasks is done.
+     */
+    std::condition_variable task_done_cv = {};
+
+    /**
+     * @brief A queue of tasks to be executed by the threads.
+     */
+    std::queue<std::function<void()>> tasks = {};
+
+    /**
+     * @brief An atomic variable to keep track of the total number of unfinished tasks - either still in the queue, or running in a thread.
+     */
+    std::atomic<size_t> tasks_total = 0;
+
+    /**
+     * @brief A mutex to synchronize access to the task queue by different threads.
+     */
+    mutable std::mutex tasks_mutex = {};
+
+    /**
+     * @brief The number of threads in the pool.
+     */
+    concurrency_t thread_count = 0;
+
+    /**
+     * @brief A smart pointer to manage the memory allocated for the threads.
+     */
+    std::unique_ptr<std::thread[]> threads = nullptr;
+
+    /**
+     * @brief An atomic variable indicating that wait_for_tasks() is active and expects to be notified whenever a task is done.
+     */
+    std::atomic<bool> waiting = false;
+};
+
+} // namespace BS

BS_thread_pool_light_test.cpp

@@ -0,0 +1,657 @@
+/**
+ * @file BS_thread_pool_light_test.cpp
+ * @author Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)
+ * @version 3.4.0
+ * @date 2023-05-12
+ * @copyright Copyright (c) 2023 Barak Shoshany. Licensed under the MIT license. If you found this project useful, please consider starring it on GitHub! If you use this library in software of any kind, please provide a link to the GitHub repository https://github.com/bshoshany/thread-pool in the source code and documentation. If you use this library in published research, please cite it as follows: Barak Shoshany, "A C++17 Thread Pool for High-Performance Scientific Computing", doi:10.5281/zenodo.4742687, arXiv:2105.00613 (May 2021)
+ *
+ * @brief BS::thread_pool_light: a fast, lightweight, and easy-to-use C++17 thread pool library. This program tests all aspects of the light version of the main library, but is not needed in order to use the library.
+ */
+
+#include <algorithm>          // std::min, std::sort, std::unique
+#include <atomic>             // std::atomic
+#include <chrono>             // std::chrono
+#include <cmath>              // std::abs
+#include <condition_variable> // std::condition_variable
+#include <cstdlib>            // std::quick_exit
+#include <exception>          // std::exception
+#include <future>             // std::future
+#include <iostream>           // std::cout
+#include <memory>             // std::make_unique, std::unique_ptr
+#include <mutex>              // std::mutex, std::scoped_lock, std::unique_lock
+#include <random>             // std::mt19937_64, std::random_device, std::uniform_int_distribution
+#include <stdexcept>          // std::runtime_error
+#include <string>             // std::string, std::to_string
+#include <thread>             // std::this_thread, std::thread
+#include <utility>            // std::forward
+#include <vector>             // std::vector
+
+// Include the header file for the thread pool library.
+#include "BS_thread_pool_light.hpp"
+
+// ================
+// Global variables
+// ================
+
+// A global thread pool object to be used throughout the test.
+BS::thread_pool_light pool;
+
+// A global random_device object to be used to seed some random number generators.
+std::random_device rd;
+
+// A global variable to measure how many checks succeeded.
+size_t tests_succeeded = 0;
+
+// A global variable to measure how many checks failed.
+size_t tests_failed = 0;
+
+// ================
+// Helper functions
+// ================
+
+/**
+ * @brief Print any number of items into std::cout.
+ *
+ * @tparam T The types of the items.
+ * @param items The items to print.
+ */
+template <typename... T>
+void print(T&&... items)
+{
+    (std::cout << ... << std::forward<T>(items));
+}
+
+/**
+ * @brief Print any number of items into std::cout, followed by a newline character.
+ *
+ * @tparam T The types of the items.
+ * @param items The items to print.
+ */
+template <typename... T>
+void println(T&&... items)
+{
+    print(std::forward<T>(items)..., '\n');
+}
+
+/**
+ * @brief Print a stylized header.
+ *
+ * @param text The text of the header. Will appear between two lines.
+ * @param symbol The symbol to use for the lines. Default is '='.
+ */
+void print_header(const std::string& text, const char symbol = '=')
+{
+    println();
+    println(std::string(text.length(), symbol));
+    println(text);
+    println(std::string(text.length(), symbol));
+}
+
+/**
+ * @brief Check if a condition is met, report the result, and keep count of the total number of successes and failures.
+ *
+ * @param condition The condition to check.
+ */
+void check(const bool condition)
+{
+    if (condition)
+    {
+        println("-> PASSED!");
+        ++tests_succeeded;
+    }
+    else
+    {
+        println("-> FAILED!");
+        ++tests_failed;
+    }
+}
+
+/**
+ * @brief Check if the expected result has been obtained, report the result, and keep count of the total number of successes and failures.
+ *
+ * @param condition The condition to check.
+ */
+template <typename T1, typename T2>
+void check(const T1 expected, const T2 obtained)
+{
+    print("Expected: ", expected, ", obtained: ", obtained);
+    if (expected == obtained)
+    {
+        println(" -> PASSED!");
+        ++tests_succeeded;
+    }
+    else
+    {
+        println(" -> FAILED!");
+        ++tests_failed;
+    }
+}
+
+// =========================================
+// Functions to verify the number of threads
+// =========================================
+
+/**
+ * @brief Count the number of unique threads in the pool. Submits a number of tasks equal to twice the thread count into the pool. Each task stores the ID of the thread running it, and then waits until released by the main thread. This ensures that each thread in the pool runs at least one task. The number of unique thread IDs is then counted from the stored IDs.
+ */
+BS::concurrency_t count_unique_threads()
+{
+    std::condition_variable ID_cv, total_cv;
+    std::mutex ID_mutex, total_mutex;
+    {
+        const BS::concurrency_t num_tasks = pool.get_thread_count() * 2;
+        std::vector<std::thread::id> thread_IDs(num_tasks);
+        std::unique_lock<std::mutex> total_lock(total_mutex);
+        BS::concurrency_t total_count = 0;
+        bool ID_release = false;
+        pool.wait_for_tasks();
+        for (std::thread::id& id : thread_IDs)
+            pool.push_task(
+                [&total_count, &id, &ID_release, &ID_cv, &total_cv, &ID_mutex, &total_mutex]
+                {
+                    id = std::this_thread::get_id();
+                    {
+                        const std::scoped_lock total_lock_local(total_mutex);
+                        ++total_count;
+                    }
+                    total_cv.notify_one();
+                    std::unique_lock<std::mutex> ID_lock_local(ID_mutex);
+                    ID_cv.wait(ID_lock_local, [&ID_release] { return ID_release; });
+                });
+        total_cv.wait(total_lock, [&total_count] { return total_count == pool.get_thread_count(); });
+        {
+            const std::scoped_lock ID_lock(ID_mutex);
+            ID_release = true;
+        }
+        ID_cv.notify_all();
+        total_cv.wait(total_lock, [&total_count, &num_tasks] { return total_count == num_tasks; });
+        pool.wait_for_tasks();
+        std::sort(thread_IDs.begin(), thread_IDs.end());
+        return static_cast<BS::concurrency_t>(std::unique(thread_IDs.begin(), thread_IDs.end()) - thread_IDs.begin());
+    }
+}
+
+/**
+ * @brief Check that the constructor works.
+ */
+void check_constructor()
+{
+    println("Checking that the thread pool reports a number of threads equal to the hardware concurrency...");
+    check(std::thread::hardware_concurrency(), pool.get_thread_count());
+    println("Checking that the manually counted number of unique thread IDs is equal to the reported number of threads...");
+    check(pool.get_thread_count(), count_unique_threads());
+}
+
+// =======================================
+// Functions to verify submission of tasks
+// =======================================
+
+/**
+ * @brief Check that push_task() works.
+ */
+void check_push_task()
+{
+    println("Checking that push_task() works for a function with no arguments or return value...");
+    {
+        bool flag = false;
+        pool.push_task([&flag] { flag = true; });
+        pool.wait_for_tasks();
+        check(flag);
+    }
+    println("Checking that push_task() works for a function with one argument and no return value...");
+    {
+        bool flag = false;
+        pool.push_task([](bool* flag_) { *flag_ = true; }, &flag);
+        pool.wait_for_tasks();
+        check(flag);
+    }
+    println("Checking that push_task() works for a function with two arguments and no return value...");
+    {
+        bool flag1 = false;
+        bool flag2 = false;
+        pool.push_task([](bool* flag1_, bool* flag2_) { *flag1_ = *flag2_ = true; }, &flag1, &flag2);
+        pool.wait_for_tasks();
+        check(flag1 && flag2);
+    }
+}
+
+/**
+ * @brief Check that submit() works.
+ */
+void check_submit()
+{
+    println("Checking that submit() works for a function with no arguments or return value...");
+    {
+        bool flag = false;
+        pool.submit([&flag] { flag = true; }).wait();
+        check(flag);
+    }
+    println("Checking that submit() works for a function with one argument and no return value...");
+    {
+        bool flag = false;
+        pool.submit([](bool* flag_) { *flag_ = true; }, &flag).wait();
+        check(flag);
+    }
+    println("Checking that submit() works for a function with two arguments and no return value...");
+    {
+        bool flag1 = false;
+        bool flag2 = false;
+        pool.submit([](bool* flag1_, bool* flag2_) { *flag1_ = *flag2_ = true; }, &flag1, &flag2).wait();
+        check(flag1 && flag2);
+    }
+    println("Checking that submit() works for a function with no arguments and a return value...");
+    {
+        bool flag = false;
+        std::future<int> flag_future = pool.submit(
+            [&flag]
+            {
+                flag = true;
+                return 42;
+            });
+        check(flag_future.get() == 42 && flag);
+    }
+    println("Checking that submit() works for a function with one argument and a return value...");
+    {
+        bool flag = false;
+        std::future<int> flag_future = pool.submit(
+            [](bool* flag_)
+            {
+                *flag_ = true;
+                return 42;
+            },
+            &flag);
+        check(flag_future.get() == 42 && flag);
+    }
+    println("Checking that submit() works for a function with two arguments and a return value...");
+    {
+        bool flag1 = false;
+        bool flag2 = false;
+        std::future<int> flag_future = pool.submit(
+            [](bool* flag1_, bool* flag2_)
+            {
+                *flag1_ = *flag2_ = true;
+                return 42;
+            },
+            &flag1, &flag2);
+        check(flag_future.get() == 42 && flag1 && flag2);
+    }
+}
+
+class flag_class
+{
+public:
+    void set_flag_no_args()
+    {
+        flag = true;
+    }
+
+    void set_flag_one_arg(const bool arg)
+    {
+        flag = arg;
+    }
+
+    int set_flag_no_args_return()
+    {
+        flag = true;
+        return 42;
+    }
+
+    int set_flag_one_arg_return(const bool arg)
+    {
+        flag = arg;
+        return 42;
+    }
+
+    bool get_flag() const
+    {
+        return flag;
+    }
+
+    void push_test_flag_no_args()
+    {
+        pool.push_task(&flag_class::set_flag_no_args, this);
+        pool.wait_for_tasks();
+        check(get_flag());
+    }
+
+    void push_test_flag_one_arg()
+    {
+        pool.push_task(&flag_class::set_flag_one_arg, this, true);
+        pool.wait_for_tasks();
+        check(get_flag());
+    }
+
+    void submit_test_flag_no_args()
+    {
+        pool.submit(&flag_class::set_flag_no_args, this).wait();
+        check(get_flag());
+    }
+
+    void submit_test_flag_one_arg()
+    {
+        pool.submit(&flag_class::set_flag_one_arg, this, true).wait();
+        check(get_flag());
+    }
+
+    void submit_test_flag_no_args_return()
+    {
+        std::future<int> flag_future = pool.submit(&flag_class::set_flag_no_args_return, this);
+        check(flag_future.get() == 42 && get_flag());
+    }
+
+    void submit_test_flag_one_arg_return()
+    {
+        std::future<int> flag_future = pool.submit(&flag_class::set_flag_one_arg_return, this, true);
+        check(flag_future.get() == 42 && get_flag());
+    }
+
+private:
+    bool flag = false;
+};
+
+/**
+ * @brief Check that submitting member functions works.
+ */
+void check_member_function()
+{
+    println("Checking that push_task() works for a member function with no arguments or return value...");
+    {
+        flag_class flag;
+        pool.push_task(&flag_class::set_flag_no_args, &flag);
+        pool.wait_for_tasks();
+        check(flag.get_flag());
+    }
+    println("Checking that push_task() works for a member function with one argument and no return value...");
+    {
+        flag_class flag;
+        pool.push_task(&flag_class::set_flag_one_arg, &flag, true);
+        pool.wait_for_tasks();
+        check(flag.get_flag());
+    }
+    println("Checking that submit() works for a member function with no arguments or return value...");
+    {
+        flag_class flag;
+        pool.submit(&flag_class::set_flag_no_args, &flag).wait();
+        check(flag.get_flag());
+    }
+    println("Checking that submit() works for a member function with one argument and no return value...");
+    {
+        flag_class flag;
+        pool.submit(&flag_class::set_flag_one_arg, &flag, true).wait();
+        check(flag.get_flag());
+    }
+    println("Checking that submit() works for a member function with no arguments and a return value...");
+    {
+        flag_class flag;
+        std::future<int> flag_future = pool.submit(&flag_class::set_flag_no_args_return, &flag);
+        check(flag_future.get() == 42 && flag.get_flag());
+    }
+    println("Checking that submit() works for a member function with one argument and a return value...");
+    {
+        flag_class flag;
+        std::future<int> flag_future = pool.submit(&flag_class::set_flag_one_arg_return, &flag, true);
+        check(flag_future.get() == 42 && flag.get_flag());
+    }
+}
+
+/**
+ * @brief Check that submitting member functions within an object works.
+ */
+void check_member_function_within_object()
+{
+    println("Checking that push_task() works within an object for a member function with no arguments or return value...");
+    {
+        flag_class flag;
+        flag.push_test_flag_no_args();
+    }
+    println("Checking that push_task() works within an object for a member function with one argument and no return value...");
+    {
+        flag_class flag;
+        flag.push_test_flag_one_arg();
+    }
+    println("Checking that submit() works within an object for a member function with no arguments or return value...");
+    {
+        flag_class flag;
+        flag.submit_test_flag_no_args();
+    }
+    println("Checking that submit() works within an object for a member function with one argument and no return value...");
+    {
+        flag_class flag;
+        flag.submit_test_flag_one_arg();
+    }
+    println("Checking that submit() works within an object for a member function with no arguments and a return value...");
+    {
+        flag_class flag;
+        flag.submit_test_flag_no_args_return();
+    }
+    println("Checking that submit() works within an object for a member function with one argument and a return value...");
+    {
+        flag_class flag;
+        flag.submit_test_flag_one_arg_return();
+    }
+}
+
+/**
+ * @brief Check that wait_for_tasks() works.
+ */
+void check_wait_for_tasks()
+{
+    const BS::concurrency_t n = pool.get_thread_count() * 10;
+    std::unique_ptr<std::atomic<bool>[]> flags = std::make_unique<std::atomic<bool>[]>(n);
+    for (BS::concurrency_t i = 0; i < n; ++i)
+        pool.push_task(
+            [&flags, i]
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                flags[i] = true;
+            });
+    println("Waiting for tasks...");
+    pool.wait_for_tasks();
+    bool all_flags = true;
+    for (BS::concurrency_t i = 0; i < n; ++i)
+        all_flags = all_flags && flags[i];
+    check(all_flags);
+}
+
+// ========================================
+// Functions to verify loop parallelization
+// ========================================
+
+/**
+ * @brief Check that push_loop() works for a specific range of indices split over a specific number of tasks, with no return value.
+ *
+ * @param random_start The first index in the loop.
+ * @param random_end The last index in the loop plus 1.
+ * @param num_tasks The number of tasks.
+ */
+template <typename T>
+void check_push_loop_no_return(const int64_t random_start, T random_end, const BS::concurrency_t num_tasks)
+{
+    if (random_start == random_end)
+        ++random_end;
+    println("Verifying that push_loop() from ", random_start, " to ", random_end, " with ", num_tasks, num_tasks == 1 ? " task" : " tasks", " modifies all indices...");
+    const size_t num_indices = static_cast<size_t>(std::abs(random_end - random_start));
+    const int64_t offset = std::min<int64_t>(random_start, static_cast<int64_t>(random_end));
+    std::unique_ptr<std::atomic<bool>[]> flags = std::make_unique<std::atomic<bool>[]>(num_indices);
+    const auto loop = [&flags, offset](const int64_t start, const int64_t end)
+    {
+        for (int64_t i = start; i < end; ++i)
+            flags[static_cast<size_t>(i - offset)] = true;
+    };
+    if (random_start == 0)
+        pool.push_loop(random_end, loop, num_tasks);
+    else
+        pool.push_loop(random_start, random_end, loop, num_tasks);
+    pool.wait_for_tasks();
+    bool all_flags = true;
+    for (size_t i = 0; i < num_indices; ++i)
+        all_flags = all_flags && flags[i];
+    check(all_flags);
+}
+
+/**
+ * @brief Check that push_loop() works using several different random values for the range of indices and number of tasks.
+ */
+void check_push_loop()
+{
+    std::mt19937_64 mt(rd());
+    std::uniform_int_distribution<int64_t> index_dist(-1000000, 1000000);
+    std::uniform_int_distribution<BS::concurrency_t> task_dist(1, pool.get_thread_count());
+    constexpr uint64_t n = 10;
+    for (uint64_t i = 0; i < n; ++i)
+        check_push_loop_no_return(index_dist(mt), index_dist(mt), task_dist(mt));
+    println("Verifying that push_loop() with identical start and end indices does nothing...");
+    bool flag = true;
+    const int64_t index = index_dist(mt);
+    pool.push_loop(index, index, [&flag](const int64_t, const int64_t) { flag = false; });
+    pool.wait_for_tasks();
+    check(flag);
+    println("Trying push_loop() with start and end indices of different types:");
+    const int64_t start = index_dist(mt);
+    const uint32_t end = static_cast<uint32_t>(std::abs(index_dist(mt)));
+    check_push_loop_no_return(start, end, task_dist(mt));
+    println("Trying the overload for push_loop() for the case where the first index is equal to 0:");
+    check_push_loop_no_return(0, index_dist(mt), task_dist(mt));
+}
+
+// ======================================
+// Functions to verify exception handling
+// ======================================
+
+/**
+ * @brief Check that exception handling works.
+ */
+void check_exceptions()
+{
+    println("Checking that exceptions are forwarded correctly by submit()...");
+    bool caught = false;
+    auto throws = []
+    {
+        println("Throwing exception...");
+        throw std::runtime_error("Exception thrown!");
+    };
+    std::future<void> my_future = pool.submit(throws);
+    try
+    {
+        my_future.get();
+    }
+    catch (const std::exception& e)
+    {
+        if (e.what() == std::string("Exception thrown!"))
+            caught = true;
+    }
+    check(caught);
+}
+
+// =====================================
+// Functions to verify vector operations
+// =====================================
+
+/**
+ * @brief Check that parallelized vector operations work as expected by calculating the sum of two randomized vectors of a specific size in two ways, single-threaded and multithreaded, and comparing the results.
+ */
+void check_vector_of_size(const size_t vector_size, const BS::concurrency_t num_tasks)
+{
+    std::vector<int64_t> vector_1(vector_size);
+    std::vector<int64_t> vector_2(vector_size);
+    std::mt19937_64 mt(rd());
+    std::uniform_int_distribution<int64_t> vector_dist(-1000000, 1000000);
+    for (size_t i = 0; i < vector_size; ++i)
+    {
+        vector_1[i] = vector_dist(mt);
+        vector_2[i] = vector_dist(mt);
+    }
+    println("Adding two vectors with ", vector_size, " elements using ", num_tasks, " tasks...");
+    std::vector<int64_t> sum_single(vector_size);
+    for (size_t i = 0; i < vector_size; ++i)
+        sum_single[i] = vector_1[i] + vector_2[i];
+    std::vector<int64_t> sum_multi(vector_size);
+    pool.push_loop(
+        0, vector_size,
+        [&sum_multi, &vector_1, &vector_2](const size_t start, const size_t end)
+        {
+            for (size_t i = start; i < end; ++i)
+                sum_multi[i] = vector_1[i] + vector_2[i];
+        },
+        num_tasks);
+    pool.wait_for_tasks();
+    bool vectors_equal = true;
+    for (size_t i = 0; i < vector_size; ++i)
+        vectors_equal = vectors_equal && (sum_single[i] == sum_multi[i]);
+    check(vectors_equal);
+}
+
+/**
+ * @brief Check that parallelized vector operations work as expected by calculating the sum of two randomized vectors in two ways, single-threaded and multithreaded, and comparing the results.
+ */
+void check_vectors()
+{
+    std::mt19937_64 mt(rd());
+    std::uniform_int_distribution<size_t> size_dist(0, 1000000);
+    std::uniform_int_distribution<BS::concurrency_t> task_dist(1, pool.get_thread_count());
+    for (size_t i = 0; i < 10; ++i)
+        check_vector_of_size(size_dist(mt), task_dist(mt));
+}
+
+// ==================
+// Main test function
+// ==================
+
+/**
+ * @brief Test that various aspects of the library are working as expected.
+ */
+void do_tests()
+{
+    print_header("Checking that the constructor works:");
+    check_constructor();
+
+    print_header("Checking that push_task() works:");
+    check_push_task();
+
+    print_header("Checking that submit() works:");
+    check_submit();
+
+    print_header("Checking that submitting member functions works:");
+    check_member_function();
+
+    print_header("Checking that submitting member functions from within an object works:");
+    check_member_function_within_object();
+
+    print_header("Checking that wait_for_tasks() works...");
+    check_wait_for_tasks();
+
+    print_header("Checking that push_loop() works:");
+    check_push_loop();
+
+    print_header("Checking that exception handling works:");
+    check_exceptions();
+
+    print_header("Testing that vector operations produce the expected results:");
+    check_vectors();
+}
+
+int main()
+{
+    println("BS::thread_pool_light: a fast, lightweight, and easy-to-use C++17 thread pool library");
+    println("(c) 2023 Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)");
+    println("GitHub: https://github.com/bshoshany/thread-pool\n");
+
+    println("Thread pool library version is ", BS_THREAD_POOL_LIGHT_VERSION, ".");
+    println("Hardware concurrency is ", std::thread::hardware_concurrency(), ".");
+
+    println("Important: Please do not run any other applications, especially multithreaded applications, in parallel with this test!");
+
+    do_tests();
+
+    if (tests_failed == 0)
+    {
+        print_header("SUCCESS: Passed all " + std::to_string(tests_succeeded) + " checks!", '+');
+        return 0;
+    }
+    else
+    {
+        print_header("FAILURE: Passed " + std::to_string(tests_succeeded) + " checks, but failed " + std::to_string(tests_failed) + "!", '+');
+        println("\nPlease submit a bug report at https://github.com/bshoshany/thread-pool/issues including the exact specifications of your system (OS, CPU, compiler, etc.) and the generated log file.");
+        std::quick_exit(static_cast<int>(tests_failed));
+    }
+}

CHANGELOG.md

@@ -10,12 +10,14 @@
 
 # `BS::thread_pool`: a fast, lightweight, and easy-to-use C++17 thread pool library
 
-By Barak Shoshany<br />
-Email: [baraksh@gmail.com](mailto:baraksh@gmail.com)<br />
-Website: [https://baraksh.com/](https://baraksh.com/)<br />
-GitHub: [https://github.com/bshoshany](https://github.com/bshoshany)<br />
+By Barak Shoshany\
+Email: <baraksh@gmail.com>\
+Website: <https://baraksh.com/>\
+GitHub: <https://github.com/bshoshany>
 
 * [Version history](#version-history)
+    * [v3.4.0 (2023-05-12)](#v340-2023-05-12)
+    * [v3.3.0 (2022-08-03)](#v330-2022-08-03)
     * [v3.2.0 (2022-07-28)](#v320-2022-07-28)
     * [v3.1.0 (2022-07-13)](#v310-2022-07-13)
     * [v3.0.0 (2022-05-30)](#v300-2022-05-30)
@@ -33,6 +35,47 @@ GitHub: [https://github.com/bshoshany](https://github.com/bshoshany)<br />
 
 ## Version history
 
+### v3.4.0 (2023-05-12)
+
+* `BS_thread_pool.hpp` and `BS_thread_pool_light.hpp`:
+    * Resolved an issue which could have caused `tasks_total` to not be synchronized in some cases. See [#70](https://github.com/bshoshany/thread-pool/pull/70).
+    * Resolved a deadlock which could rarely be caused when the pool was destructed or reset. See [#93](https://github.com/bshoshany/thread-pool/pull/93), [#100](https://github.com/bshoshany/thread-pool/pull/100), [#107](https://github.com/bshoshany/thread-pool/pull/107), and [#108](https://github.com/bshoshany/thread-pool/pull/108).
+    * Resolved a deadlock which could be caused when `wait_for_tasks()` was called more than once.
+    * Two new member functions have been added to the non-light version: `wait_for_tasks_duration()` and `wait_for_tasks_until()`. They allow waiting for the tasks to complete, but with a timeout. `wait_for_tasks_duration()` will stop waiting after the specified duration has passed, and `wait_for_tasks_until()` will stop waiting after the specified time point has been reached.
+    * Renamed `BS_THREAD_POOL_VERSION` in `BS_thread_pool_light.hpp` to `BS_THREAD_POOL_LIGHT_VERSION` and removed the `[light]` tag. This allows including both header files in the same program in case we want to use both the light and non-light thread pools simultaneously.
+* `BS_thread_pool_test.cpp` and `BS_thread_pool_light_test.cpp`:
+    * Fixed an issue that caused a compilation error when using MSVC and including `Windows.h`. See [#72](https://github.com/bshoshany/thread-pool/pull/72).
+    * The number and size of the vectors in the performance test (`BS_thread_pool_test.cpp` only) are now guaranteed to be multiples of the number of threads, for optimal performance.
+    * In `count_unique_threads()`, moved the condition variables and mutexes to the function scope to prevent cluttering the global scope.
+    * Three new tests have been added to `BS_thread_pool_test.cpp` to check the deadlocks issue that were resolved in this release (see above). The tests rely on the new wait for tasks with timeout feature, so they are not available in the light version.
+        * One test checks for deadlocks when calling `wait_for_tasks()` more than once.
+        * Two tests check for deadlocks when destructing and resetting the pool respectively. They are turned off by default, since they take a long time to complete, but can be turned on by setting `enable_long_deadlock_tests` to `true`.
+    * Two new tests have been added to the non-light version to check the new member functions `wait_for_tasks_duration()` and `wait_for_tasks_until()`.
+    * The test programs now return the number of failed tests upon exit, instead of just 1 if any number of tests failed, which was the case in previous versions. Also, if any tests failed, `std::quick_exit()` is invoked instead of `return`, to avoid getting stuck due to any lingering tasks or deadlocks.
+* `README.md`:
+    * Added documentation for the two new member functions, `wait_for_tasks_duration()` and `wait_for_tasks_until()`.
+    * Fixed Markdown rendering incorrectly on Visual Studio. See [#77](https://github.com/bshoshany/thread-pool/pull/77).
+    * The sample performance tests are now taken from a 40-core / 80-thread dual-CPU computing node, which is a more typical use case for high-performance scientific software.
+
+### v3.3.0 (2022-08-03)
+
+* `BS_thread_pool.hpp`:
+    * The public member variable `paused` of `BS::thread_pool` has been made private for future-proofing (in case future versions implement a more involved pausing mechanism) and better encapsulation. It is now accessible only via the `pause()`, `unpause()`, and `is_paused()` member functions. In other words:
+        * Replace `pool.paused = true` with `pool.pause()`.
+        * Replace `pool.paused = false` with `pool.unpause()`.
+        * Replace `if (pool.paused)` (or similar) with `if (pool.is_paused())`.
+    * The public member variable `f` of `BS::multi_future` has been renamed to `futures` for clarity, and has been made private for encapsulation and simplification purposes. Instead of operating on the vector `futures` itself, you can now use the `[]` operator of the `BS::multi_future` to access the future at a specific index directly, or the `push_back()` member function to append a new future to the list. The `size()` member function tells you how many futures are currently stored in the object.
+    * The explicit casts of `std::endl` and `std::flush`, added in v3.2.0 to enable flushing a `BS::synced_stream`, caused ODR (One Definition Rule) violations if `BS_thread_pool.hpp` was included in two different translation units, since they were mistakenly not defined as `inline`. To fix this, I decided to make them static members of `BS::synced_stream` instead of global variables, which also makes the code better organized in my opinion. These objects can now be accessed as `BS::synced_stream::endl` and `BS::synced_stream::flush`. I also added an example for how to use them in `README.md`. See [#64](https://github.com/bshoshany/thread-pool/issues/64).
+* `BS_thread_pool_light.hpp`:
+    * This package started out as a very lightweight thread pool, but over time has expanded to include many additional features, and at the time of writing it has a total of 340 lines of code, including all the helper classes. Therefore, I have decided to bundle a light version of the thread pool in a separate and stand-alone header file, `BS_thread_pool_light.hpp`, with only 170 lines of code (half the size of the full package). This file does not contain any of the helper classes, only a new `BS::thread_pool_light` class, which is a minimal thread pool with only the 5 most basic member functions:
+        * `get_thread_count()`
+        * `push_loop()`
+        * `push_task()`
+        * `submit()`
+        * `wait_for_tasks()`
+    * A separate test program `BS_thread_pool_light_test.cpp` tests only the features of the lightweight `BS::thread_pool_light` class. In the spirit of minimalism, it does not generate a log file and does not do any benchmarks.
+    * To be perfectly clear, each header file is 100% stand-alone. If you wish to use the full package, you only need `BS_thread_pool.hpp`, and if you wish to use the light version, you only need `BS_thread_pool_light.hpp`. Only a single header file needs to be included in your project.
+
 ### v3.2.0 (2022-07-28)
 
 * `BS_thread_pool.hpp`:

LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Barak Shoshany
+Copyright (c) 2023 Barak Shoshany
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -10,12 +10,12 @@
 
 # `BS::thread_pool`: a fast, lightweight, and easy-to-use C++17 thread pool library
 
-By Barak Shoshany<br />
-Email: [baraksh@gmail.com](mailto:baraksh@gmail.com)<br />
-Website: [https://baraksh.com/](https://baraksh.com/)<br />
-GitHub: [https://github.com/bshoshany](https://github.com/bshoshany)<br />
+By Barak Shoshany\
+Email: <baraksh@gmail.com>\
+Website: <https://baraksh.com/>\
+GitHub: <https://github.com/bshoshany>
 
-This is the complete documentation for v3.2.0 of the library, released on 2022-07-28.
+This is the complete documentation for v3.4.0 of the library, released on 2023-05-12.
 
 * [Introduction](#introduction)
     * [Motivation](#motivation)
@@ -32,13 +32,15 @@ This is the complete documentation for v3.2.0 of the library, released on 2022-0
     * [Submitting tasks to the queue with futures](#submitting-tasks-to-the-queue-with-futures)
     * [Submitting tasks to the queue without futures](#submitting-tasks-to-the-queue-without-futures)
     * [Manually waiting for all tasks to complete](#manually-waiting-for-all-tasks-to-complete)
+    * [Waiting with a timeout](#waiting-with-a-timeout)
     * [Submitting class member functions to the queue](#submitting-class-member-functions-to-the-queue)
-    * [Parallelizing loops](#parallelizing-loops)
+* [Parallelizing loops](#parallelizing-loops)
+    * [Automatic parallelization of loops](#automatic-parallelization-of-loops)
     * [Loops with return values](#loops-with-return-values)
     * [Parallelizing loops without futures](#parallelizing-loops-without-futures)
 * [Helper classes](#helper-classes)
-    * [Handling multiple futures at once](#handling-multiple-futures-at-once)
     * [Synchronizing printing to an output stream](#synchronizing-printing-to-an-output-stream)
+    * [Handling multiple futures at once](#handling-multiple-futures-at-once)
     * [Measuring execution time](#measuring-execution-time)
 * [Other features](#other-features)
     * [Monitoring the tasks](#monitoring-the-tasks)
@@ -47,6 +49,7 @@ This is the complete documentation for v3.2.0 of the library, released on 2022-0
 * [Testing the package](#testing-the-package)
     * [Automated tests](#automated-tests)
     * [Performance tests](#performance-tests)
+* [The light version of the package](#the-light-version-of-the-package)
 * [About the project](#about-the-project)
     * [Issue and pull request policy](#issue-and-pull-request-policy)
     * [Acknowledgements](#acknowledgements)
@@ -57,13 +60,13 @@ This is the complete documentation for v3.2.0 of the library, released on 2022-0
 
 ### Motivation
 
-Multithreading is essential for modern high-performance computing. Since C++11, the C++ standard library has included built-in low-level multithreading support using constructs such as `std::thread`. However, `std::thread` creates a new thread each time it is called, which can have a significant performance overhead. Furthermore, it is possible to create more threads than the hardware can handle simultaneously, potentially resulting in a substantial slowdown.
+Multithreading is essential for modern high-performance computing. Since C\+\+11, the C++ standard library has included built-in low-level multithreading support using constructs such as `std::thread`. However, `std::thread` creates a new thread each time it is called, which can have a significant performance overhead. Furthermore, it is possible to create more threads than the hardware can handle simultaneously, potentially resulting in a substantial slowdown.
 
-The library presented here contains a thread pool class, `BS::thread_pool`, which avoids these issues by creating a fixed pool of threads once and for all, and then continuously reusing the same threads to perform different tasks throughout the lifetime of the program. By default, the number of threads in the pool is equal to the maximum number of threads that the hardware can run in parallel.
+The library presented here contains a C++ thread pool class, `BS::thread_pool`, which avoids these issues by creating a fixed pool of threads once and for all, and then continuously reusing the same threads to perform different tasks throughout the lifetime of the program. By default, the number of threads in the pool is equal to the maximum number of threads that the hardware can run in parallel.
 
 The user submits tasks to be executed into a queue. Whenever a thread becomes available, it retrieves the next task from the queue and executes it. The pool automatically produces an `std::future` for each task, which allows the user to wait for the task to finish executing and/or obtain its eventual return value, if applicable. Threads and tasks are autonomously managed by the pool in the background, without requiring any input from the user aside from submitting the desired tasks.
 
-The design of this package was guided by four important principles. First, *compactness*: the entire library consists of just one small self-contained header file, with no other components or dependencies. Second, *portability*: the package only utilizes the C++17 standard library, without relying on any compiler extensions or 3rd-party libraries, and is therefore compatible with any modern standards-conforming C++17 compiler on any platform. Third, *ease of use*: the package is extensively documented, and programmers of any level should be able to use it right out of the box.
+The design of this package was guided by four important principles. First, *compactness*: the entire library consists of just one small self-contained header file, with no other components or dependencies. Second, *portability*: the package only utilizes the C\+\+17 standard library, without relying on any compiler extensions or 3rd-party libraries, and is therefore compatible with any modern standards-conforming C\+\+17 compiler on any platform. Third, *ease of use*: the package is extensively documented, and programmers of any level should be able to use it right out of the box.
 
 The fourth and final guiding principle is *performance*: each and every line of code in this library was carefully designed with maximum performance in mind, and performance was tested and verified on a variety of compilers and platforms. Indeed, the library was originally designed for use in the author's own computationally-intensive scientific computing projects, running both on high-end desktop/laptop computers and high-performance computing nodes.
 
@@ -78,11 +81,12 @@ Other, more advanced multithreading libraries may offer more features and/or hig
     * Reusing threads avoids the overhead of creating and destroying them for individual tasks.
     * A task queue ensures that there are never more threads running in parallel than allowed by the hardware.
 * **Lightweight:**
-    * Only ~190 lines of code, excluding comments, blank lines, and the optional helper classes.
     * Single header file: simply `#include "BS_thread_pool.hpp"` and you're all set!
     * Header-only: no need to install or build the library.
     * Self-contained: no external requirements or dependencies.
     * Portable: uses only the C++ standard library, and works with any C++17-compliant compiler.
+    * Only ~340 lines of code, excluding comments and blank lines.
+    * A stand-alone "light version" of the C++ thread pool is also available in the `BS_thread_pool_light.hpp` header file, with only ~170 lines of code.
 * **Easy to use:**
     * Very simple operation, using a handful of member functions.
     * Every task submitted to the queue using the `submit()` member function automatically generates an `std::future`, which can be used to wait for the task to finish executing and/or obtain its eventual return value.
@@ -97,28 +101,28 @@ Other, more advanced multithreading libraries may offer more features and/or hig
     * Easily wait for all tasks in the queue to complete using the `wait_for_tasks()` member function.
     * Change the number of threads in the pool safely and on-the-fly as needed using the `reset()` member function.
     * Monitor the number of queued and/or running tasks using the `get_tasks_queued()`, `get_tasks_running()`, and `get_tasks_total()` member functions.
-    * Freely pause and resume the pool by modifying the `paused` member variable. When paused, threads do not retrieve new tasks out of the queue.
+    * Freely pause and resume the pool using the `pause()`, `unpause()`, and `is_paused()` member functions. When paused, threads do not retrieve new tasks out of the queue.
     * Catch exceptions thrown by the submitted tasks.
     * Submit class member functions to the pool, either applied to a specific object or from within the object itself.
     * Under continuous and active development. Bug reports and feature requests are welcome, and should be made via [GitHub issues](https://github.com/bshoshany/thread-pool/issues).
 
 ### Compiling and compatibility
 
-This library should successfully compile on any C++17 standard-compliant compiler, on all operating systems and architectures for which such a compiler is available. Compatibility was verified with a 12-core / 24-thread AMD Ryzen 9 3900X CPU using the following compilers and platforms:
+This library should successfully compile on any C++17 standard-compliant compiler, on all operating systems and architectures for which such a compiler is available. Compatibility was verified with a 24-core (8P+16E) / 32-thread Intel i9-13900K CPU using the following compilers and platforms:
 
-* Windows 11 build 22000.795:
-    * [Clang](https://clang.llvm.org/) v14.0.6
-    * [GCC](https://gcc.gnu.org/) v12.1.0 ([WinLibs build](https://winlibs.com/))
-    * [MSVC](https://docs.microsoft.com/en-us/cpp/) v19.32.31332
-* Ubuntu 22.04 LTS:
-    * [Clang](https://clang.llvm.org/) v14.0.0
-    * [GCC](https://gcc.gnu.org/) v12.0.1
+* Windows 11 build 22621.1702:
+    * [Clang](https://clang.llvm.org/) v16.0.3
+    * [GCC](https://gcc.gnu.org/) v13.1.0 ([WinLibs build](https://winlibs.com/))
+    * [MSVC](https://docs.microsoft.com/en-us/cpp/) v19.35.32217.1
+* Ubuntu 22.10:
+    * [Clang](https://clang.llvm.org/) v15.0.7
+    * [GCC](https://gcc.gnu.org/) v12.2.0
 
-In addition, this library was tested on a [Compute Canada](https://www.computecanada.ca/) node equipped with two 20-core / 40-thread Intel Xeon Gold 6148 CPUs (for a total of 40 cores and 80 threads), running CentOS Linux 7.9.2009, using [GCC](https://gcc.gnu.org/) v12.1.1.
+In addition, this library was tested on a [Digital Research Alliance of Canada](https://alliancecan.ca/en) node equipped with two 20-core / 40-thread Intel Xeon Gold 6148 CPUs (for a total of 40 cores and 80 threads), running CentOS Linux 7.9.2009, using [GCC](https://gcc.gnu.org/) v12.2.0.
 
 The test program `BS_thread_pool_test.cpp` was compiled without warnings (with the warning flags `-Wall -Wextra -Wconversion -Wsign-conversion -Wpedantic -Weffc++ -Wshadow` in GCC/Clang and `/W4` in MSVC), executed, and successfully completed all [automated tests](#testing-the-package) and benchmarks using all of the compilers and systems mentioned above.
 
-As this library requires C++17 features, the code must be compiled with C++17 support:
+As this library requires C\+\+17 features, the code must be compiled with C\+\+17 support:
 
 * For Clang or GCC, use the `-std=c++17` flag. On Linux, you will also need to use the `-pthread` flag to enable the POSIX threads library.
 * For MSVC, use `/std:c++17`, and preferably also `/permissive-` to ensure standards conformance.
@@ -151,7 +155,7 @@ On Windows:
 .\vcpkg install bshoshany-thread-pool:x86-windows bshoshany-thread-pool:x64-windows
 ```
 
-The thread pool will then be available automatically in the build system you integrated vcpkg with (e.g. MSBuild or CMake). Simply write `#include "BS_thread_pool.hpp"` in any project to use the thread pool, without having to copy to file into the project first. I will update the vcpkg port with each new release, so it will be updated automatically when you run `vcpkg upgrade`.
+The C++ thread pool will then be available automatically in the build system you integrated vcpkg with (e.g. MSBuild or CMake). Simply write `#include "BS_thread_pool.hpp"` in any project to use the thread pool, without having to copy to file into the project first. I will update the vcpkg port with each new release, so it will be updated automatically when you run `vcpkg upgrade`.
 
 Please see the [vcpkg repository](https://github.com/microsoft/vcpkg) for more information on how to use vcpkg.
 
@@ -210,7 +214,7 @@ std::cout << "Thread pool library version is " << BS_THREAD_POOL_VERSION << ".\n
 Sample output:
 
 ```none
-Thread pool library version is v3.1.0 (2022-07-13).
+Thread pool library version is v3.4.0 (2023-05-12).
 ```
 
 This can be used, for example, to allow the same code to work with several incompatible versions of the library.
@@ -369,6 +373,51 @@ after the `for` loop will ensure - as efficiently as possible - that all tasks h
 
 Note, however, that `wait_for_tasks()` will wait for **all** the tasks in the queue, including those that are unrelated to the `for` loop. Using [`parallelize_loop()`](#parallelizing-loops) would make much more sense in this particular case, as it will allow waiting only for the tasks related to the loop.
 
+### Waiting with a timeout
+
+Sometimes you may wish to wait for the tasks to complete, but only for a certain amount of time, or until a specific point in time. For example, if the tasks have not yet completed after some time, you may wish to let the user know that there is a delay. This can be achieved using two member functions:
+
+* `wait_for_tasks_duration()` waits for the tasks to be completed, but stops waiting after the specified duration, given as an argument of type `std::chrono::duration`, has passed.
+* `wait_for_tasks_until()` waits for the tasks to be completed, but stops waiting after the specified time point, given as an argument of type `std::chrono::time_point`, has been reached.
+
+Here is an example:
+
+```cpp
+#include "BS_thread_pool.hpp"
+
+int main()
+{
+    BS::synced_stream sync_out;
+    BS::thread_pool pool;
+    std::atomic<bool> done = false;
+    pool.push_task(
+        [&done]
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+            done = true;
+        });
+    while (true)
+    {
+        pool.wait_for_tasks_duration(std::chrono::milliseconds(200));
+        if (!done)
+            sync_out.println("Sorry, task is not done yet.");
+        else
+            break;
+    }
+    sync_out.println("Task done!");
+}
+```
+
+The output is:
+
+```none
+Sorry, task is not done yet.
+Sorry, task is not done yet.
+Sorry, task is not done yet.
+Sorry, task is not done yet.
+Task done!
+```
+
 ### Submitting class member functions to the queue
 
 Consider the following program:
@@ -467,7 +516,9 @@ int main()
 }
 ```
 
-### Parallelizing loops
+## Parallelizing loops
+
+### Automatic parallelization of loops
 
 One of the most common and effective methods of parallelization is splitting a loop into smaller loops and running them in parallel. It is most effective in "embarrassingly parallel" computations, such as vector or matrix operations, where each iteration of the loop is completely independent of every other iteration. For example, if we are summing up two vectors of 1000 elements each, and we have 10 threads, we could split the summation into 10 blocks of 100 elements each, and run all the blocks in parallel, potentially increasing performance by up to a factor of 10.
 
@@ -627,47 +678,6 @@ As with `parallelize_loop()`, the first argument can be omitted if the start ind
 
 ## Helper classes
 
-### Handling multiple futures at once
-
-The helper class template `BS::multi_future<T>`, already introduced in the context of `parallelize_loop()`, provides a convenient way to collect and access groups of futures. The futures are stored in a public member variable `f` of type `std::vector<std::future<T>>`, so all standard `std::vector` operations are available for organizing the futures. Once the futures are stored, you can use `wait()` to wait for all of them at once or `get()` to get an `std::vector<T>` with the results from all of them. Here's a simple example:
-
-```cpp
-#include "BS_thread_pool.hpp"
-
-int square(const int i)
-{
-    std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    return i * i;
-};
-
-int main()
-{
-    BS::thread_pool pool;
-    BS::multi_future<int> mf1;
-    BS::multi_future<int> mf2;
-    for (int i = 0; i < 100; ++i)
-        mf1.f.push_back(pool.submit(square, i));
-    for (int i = 100; i < 200; ++i)
-        mf2.f.push_back(pool.submit(square, i));
-    /// ...
-    /// Do some stuff while the first group of tasks executes...
-    /// ...
-    const std::vector<int> squares1 = mf1.get();
-    std::cout << "Results from the first group:" << '\n';
-    for (const int s : squares1)
-        std::cout << s << ' ';
-    /// ...
-    /// Do other stuff while the second group of tasks executes...
-    /// ...
-    const std::vector<int> squares2 = mf2.get();
-    std::cout << '\n' << "Results from the second group:" << '\n';
-    for (const int s : squares2)
-        std::cout << s << ' ';
-}
-```
-
-In this example, we simulate complicated tasks by having each task wait for 500ms before returning its result. We collect the futures of the tasks submitted within each loop into two separate `BS::multi_future<int>` objects. `mf1` holds the results from the first loop, and `mf2` holds the results from the second loop. Now we can wait for and/or get the results from `mf1` whenever is convenient, and separately wait for and/or get the results from `mf2` at another time.
-
 ### Synchronizing printing to an output stream
 
 When printing to an output stream from multiple threads in parallel, the output may become garbled. For example, consider this code:
@@ -732,6 +742,94 @@ Task no. 5 executing.
 
 **Warning:** Always create the `BS::synced_stream` object **before** the `BS::thread_pool` object, as we did in this example. When the `BS::thread_pool` object goes out of scope, it waits for the remaining tasks to be executed. If the `BS::synced_stream` object goes out of scope before the `BS::thread_pool` object, then any tasks using the `BS::synced_stream` will crash. Since objects are destructed in the opposite order of construction, creating the `BS::synced_stream` object before the `BS::thread_pool` object ensures that the `BS::synced_stream` is always available to the tasks, even while the pool is destructing.
 
+Most stream manipulators defined in the headers `<ios>` and `<iomanip>`, such as `std::setw` (set the character width of the next output), `std::setprecision` (set the precision of floating point numbers), and `std::fixed` (display floating point numbers with a fixed number of digits), can be passed to `print()` and `println()` just as you would pass them to a stream.
+
+The only exceptions are the flushing manipulators `std::endl` and `std::flush`, which will not work because the compiler will not be able to figure out which template specializations to use. Instead, use `BS::synced_stream::endl` and `BS::synced_stream::flush`. Here is an example:
+
+```cpp
+#include "BS_thread_pool.hpp"
+#include <cmath>
+#include <iomanip>
+
+int main()
+{
+    BS::synced_stream sync_out;
+    BS::thread_pool pool;
+    sync_out.print(std::setprecision(10), std::fixed);
+    for (size_t i = 1; i <= 10; ++i)
+        pool.push_task([i, &sync_out] { sync_out.print("The square root of ", std::setw(2), i, " is ", std::sqrt(i), ".", BS::synced_stream::endl); });
+}
+```
+
+### Handling multiple futures at once
+
+The helper class template `BS::multi_future<T>`, already introduced in the context of `parallelize_loop()`, provides a convenient way to collect and access groups of futures. This class works similarly to STL containers such as `std::vector`:
+
+* When you create a new object, either use the default constructor to create an empty object and add futures to it later, or pass the desired number of futures to the constructor in advance.
+* Use the `[]` operator to access the future at a specific index, or the `push_back()` member function to append a new future to the list.
+* The `size()` member function tells you how many futures are currently stored in the object.
+* Once all the futures are stored, you can use `wait()` to wait for all of them at once or `get()` to get an `std::vector<T>` with the results from all of them.
+
+Aside from using `BS::multi_future` to track the execution of parallelized loops, it can also be used whenever you have several different groups of tasks and you want to track the execution of each group individually. Here's a simple example:
+
+```cpp
+#include "BS_thread_pool.hpp"
+#include <cmath>
+
+BS::synced_stream sync_out;
+BS::thread_pool pool;
+
+double power(const double i, const double j)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(10 * pool.get_thread_count()));
+    return std::pow(i, j);
+}
+
+void print_vector(const std::vector<double>& vec)
+{
+    for (const double i : vec)
+        sync_out.print(i, ' ');
+    sync_out.println();
+}
+
+int main()
+{
+    constexpr size_t n = 100;
+
+    // First group of tasks: calculate n squares.
+    // Here we create an empty BS::multi_future object, and append futures to it via push_back().
+    BS::multi_future<double> mf_squares;
+    for (int i = 0; i < n; ++i)
+        mf_squares.push_back(pool.submit(power, i, 2));
+
+    // Second group of tasks: calculate n cubes.
+    // In this case, we create a BS::multi_future object of the desired size in advance, and store the futures via the [] operator. This is faster since there will be no memory reallocations, but also more prone to errors.
+    BS::multi_future<double> mf_cubes(n);
+    for (int i = 0; i < n; ++i)
+        mf_cubes[i] = pool.submit(power, i, 3);
+
+    // Both groups are now queued, but it will take some time until they all execute.
+
+    /// ...
+    /// Do some stuff while the first group of tasks executes...
+    /// ...
+
+    // Get and print the results from the first group.
+    sync_out.println("Squares:");
+    print_vector(mf_squares.get());
+
+    /// ...
+    /// Do other stuff while the second group of tasks executes...
+    /// ...
+
+    // Get and print the results from the second group.
+    sync_out.println("Cubes:");
+    print_vector(mf_cubes.get());
+}
+```
+
+In this example, we simulate complicated tasks by having each task wait for a bit before returning its result. We collect the futures of the tasks submitted within each group into two separate `BS::multi_future<double>` objects. `mf_squares` holds the results from the first group, and `mf_cubes` holds the results from the second group. Now we can wait for and/or get the results from `mf_squares` whenever is convenient, and separately wait for and/or get the results from `mf_cubes` at another time.
+
 ### Measuring execution time
 
 If you are using a thread pool, then your code is most likely performance-critical. Achieving maximum performance requires performing a considerable amount of benchmarking to determine the optimal settings and algorithms. Therefore, it is important to be able to measure the execution time of various computations and operations under different conditions.
@@ -822,9 +920,9 @@ Task 11 done.
 
 ### Pausing the workers
 
-Sometimes you may wish to temporarily pause the execution of tasks, or perhaps you want to submit tasks to the queue in advance and only start executing them at a later time. You can do this using the public member variable `paused`.
+Sometimes you may wish to temporarily pause the execution of tasks, or perhaps you want to submit tasks to the queue in advance and only start executing them at a later time. You can do this using the member functions `pause()`, `unpause()`, and `is_paused()`.
 
-When `paused` is set to `true`, the workers will temporarily stop retrieving new tasks out of the queue. However, any tasks already executed will keep running until they are done, since the thread pool has no control over the internal code of your tasks. If you need to pause a task in the middle of its execution, you must do that manually by programming your own pause mechanism into the task itself. To resume retrieving tasks, set `paused` back to its default value of `false`.
+When you call `pause()`, the workers will temporarily stop retrieving new tasks out of the queue. However, any tasks already executed will keep running until they are done, since the thread pool has no control over the internal code of your tasks. If you need to pause a task in the middle of its execution, you must do that manually by programming your own pause mechanism into the task itself. To resume retrieving tasks, call `unpause()`. To check whether the pool is currently paused, call `is_paused()`.
 
 Here is an example:
 
@@ -840,14 +938,22 @@ void sleep_half_second(const size_t i)
     sync_out.println("Task ", i, " done.");
 }
 
+void check_if_paused()
+{
+    if (pool.is_paused())
+        sync_out.println("Pool paused.");
+    else
+        sync_out.println("Pool unpaused.");
+}
+
 int main()
 {
     for (size_t i = 0; i < 8; ++i)
         pool.push_task(sleep_half_second, i);
     sync_out.println("Submitted 8 tasks.");
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
-    pool.paused = true;
-    sync_out.println("Pool paused.");
+    pool.pause();
+    check_if_paused();
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     sync_out.println("Still paused...");
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
@@ -856,8 +962,8 @@ int main()
     sync_out.println("Submitted 4 more tasks.");
     sync_out.println("Still paused...");
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    pool.paused = false;
-    sync_out.println("Pool resumed.");
+    pool.unpause();
+    check_if_paused();
 }
 ```
 
@@ -873,7 +979,7 @@ Task 3 done.
 Still paused...
 Submitted 4 more tasks.
 Still paused...
-Pool resumed.
+Pool unpaused.
 Task 4 done.
 Task 5 done.
 Task 6 done.
@@ -884,7 +990,7 @@ Task 10 done.
 Task 11 done.
 ```
 
-Here is what happened. We initially submitted a total of 8 tasks to the queue. Since we waited for 250ms before pausing, the first 4 tasks have already started running, so they kept running until they finished. While the pool was paused, we submitted 4 more tasks to the queue, but they just waited at the end of the queue. When we resumed, the remaining 4 initial tasks were executed, followed by the 4 new tasks.
+Here is what happened. We initially submitted a total of 8 tasks to the queue. Since we waited for 250ms before pausing, the first 4 tasks have already started running, so they kept running until they finished. While the pool was paused, we submitted 4 more tasks to the queue, but they just waited at the end of the queue. When we unpaused, the remaining 4 initial tasks were executed, followed by the 4 new tasks.
 
 While the workers are paused, `wait_for_tasks()` will wait for the running tasks instead of all tasks (otherwise it would wait forever). This is demonstrated by the following program:
 
@@ -900,6 +1006,14 @@ void sleep_half_second(const size_t i)
     sync_out.println("Task ", i, " done.");
 }
 
+void check_if_paused()
+{
+    if (pool.is_paused())
+        sync_out.println("Pool paused.");
+    else
+        sync_out.println("Pool unpaused.");
+}
+
 int main()
 {
     for (size_t i = 0; i < 8; ++i)
@@ -910,8 +1024,9 @@ int main()
         pool.push_task(sleep_half_second, i);
     sync_out.println("Submitted 12 more tasks.");
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
-    pool.paused = true;
-    sync_out.println("Pool paused. Waiting for the ", pool.get_tasks_running(), " running tasks to complete.");
+    pool.pause();
+    check_if_paused();
+    sync_out.println("Waiting for the ", pool.get_tasks_running(), " running tasks to complete.");
     pool.wait_for_tasks();
     sync_out.println("All running tasks completed. ", pool.get_tasks_queued(), " tasks still queued.");
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
@@ -919,9 +1034,10 @@ int main()
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     sync_out.println("Still paused...");
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    pool.paused = false;
+    pool.unpause();
+    check_if_paused();
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
-    sync_out.println("Pool resumed. Waiting for the remaining ", pool.get_tasks_total(), " tasks (", pool.get_tasks_running(), " running and ", pool.get_tasks_queued(), " queued) to complete.");
+    sync_out.println("Waiting for the remaining ", pool.get_tasks_total(), " tasks (", pool.get_tasks_running(), " running and ", pool.get_tasks_queued(), " queued) to complete.");
     pool.wait_for_tasks();
     sync_out.println("All tasks completed.");
 }
@@ -940,7 +1056,8 @@ Task 5 done.
 Task 6 done.
 Task 7 done.
 Submitted 12 more tasks.
-Pool paused. Waiting for the 4 running tasks to complete.
+Pool paused.
+Waiting for the 4 running tasks to complete.
 Task 8 done.
 Task 9 done.
 Task 10 done.
@@ -948,7 +1065,8 @@ Task 11 done.
 All running tasks completed. 8 tasks still queued.
 Still paused...
 Still paused...
-Pool resumed. Waiting for the remaining 8 tasks (4 running and 4 queued) to complete.
+Pool unpaused.
+Waiting for the remaining 8 tasks (4 running and 4 queued) to complete.
 Task 12 done.
 Task 13 done.
 Task 14 done.
@@ -960,7 +1078,7 @@ Task 19 done.
 All tasks completed.
 ```
 
-The first `wait_for_tasks()`, which was called with `paused == false`, waited for all 8 tasks, both running and queued. The second `wait_for_tasks()`, which was called with `paused == true`, only waited for the 4 running tasks, while the other 8 tasks remained queued, and were not executed since the pool was paused. Finally, the third `wait_for_tasks()`, which was called with `paused == false`, waited for the remaining 8 tasks, both running and queued.
+The first `wait_for_tasks()`, which was called while the pool was not paused, waited for all 8 tasks, both running and queued. The second `wait_for_tasks()`, which was called after pausing the pool, only waited for the 4 running tasks, while the other 8 tasks remained queued, and were not executed since the pool was paused. Finally, the third `wait_for_tasks()`, which was called after unpausing the pool, waited for the remaining 8 tasks, both running and queued.
 
 **Warning**: If the thread pool is destroyed while paused, any tasks still in the queue will never be executed!
 
@@ -1056,12 +1174,12 @@ A sample output of a successful run of the automated tests is as follows:
 
 ```none
 BS::thread_pool: a fast, lightweight, and easy-to-use C++17 thread pool library
-(c) 2022 Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)
+(c) 2023 Barak Shoshany (baraksh@gmail.com) (http://baraksh.com)
 GitHub: https://github.com/bshoshany/thread-pool
 
-Thread pool library version is v3.2.0 (2022-07-28).
-Hardware concurrency is 24.
-Generating log file: BS_thread_pool_test-2022-07-28_15.29.31.log.
+Thread pool library version is v3.4.0 (2023-05-12).
+Hardware concurrency is 32.
+Generating log file: BS_thread_pool_test-2023-05-12_12.48.13.log.
 
 Important: Please do not run any other applications, especially multithreaded applications, in parallel with this test!
 
@@ -1069,21 +1187,21 @@ Important: Please do not run any other applications, especially multithreaded ap
 Checking that the constructor works:
 ====================================
 Checking that the thread pool reports a number of threads equal to the hardware concurrency...
-Expected: 24, obtained: 24 -> PASSED!
+Expected: 32, obtained: 32 -> PASSED!
 Checking that the manually counted number of unique thread IDs is equal to the reported number of threads...
-Expected: 24, obtained: 24 -> PASSED!
+Expected: 32, obtained: 32 -> PASSED!
 
 ============================
 Checking that reset() works:
 ============================
 Checking that after reset() the thread pool reports a number of threads equal to half the hardware concurrency...
-Expected: 12, obtained: 12 -> PASSED!
+Expected: 16, obtained: 16 -> PASSED!
 Checking that after reset() the manually counted number of unique thread IDs is equal to the reported number of threads...
-Expected: 12, obtained: 12 -> PASSED!
+Expected: 16, obtained: 16 -> PASSED!
 Checking that after a second reset() the thread pool reports a number of threads equal to the hardware concurrency...
-Expected: 24, obtained: 24 -> PASSED!
+Expected: 32, obtained: 32 -> PASSED!
 Checking that after a second reset() the manually counted number of unique thread IDs is equal to the reported number of threads...
-Expected: 24, obtained: 24 -> PASSED!
+Expected: 32, obtained: 32 -> PASSED!
 
 ================================
 Checking that push_task() works:
@@ -1148,82 +1266,95 @@ Checking that wait_for_tasks() works...
 =======================================
 Waiting for tasks...
 -> PASSED!
+Checking for deadlocks when waiting for tasks...
+All waiting tasks successfully finished!
+-> PASSED!
+Checking that wait_for_tasks_duration() works...
+Task submitted. Waiting for 10ms...
+-> PASSED!
+Waiting for 500ms...
+-> PASSED!
+Checking that wait_for_tasks_until() works...
+Task submitted. Waiting until 10ms from submission time...
+-> PASSED!
+Waiting until 500ms from submission time...
+-> PASSED!
 
 ======================================================
 Checking that push_loop() and parallelize_loop() work:
 ======================================================
-Verifying that push_loop() from 390892 to 541943 with 20 tasks modifies all indices...
+Verifying that push_loop() from 117855 to 168463 with 25 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from -233617 to 52646 with 22 tasks modifies all indices...
+Verifying that push_loop() from -788069 to -860364 with 21 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from 409845 to 410887 with 23 tasks modifies all indices...
+Verifying that push_loop() from 545486 to 553538 with 15 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from 977764 to 726111 with 12 tasks modifies all indices...
+Verifying that push_loop() from 987439 to 166022 with 29 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from -940107 to -882673 with 18 tasks modifies all indices...
+Verifying that push_loop() from 843125 to 395220 with 19 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from -613072 to 675872 with 10 tasks modifies all indices...
+Verifying that push_loop() from 75069 to 552964 with 3 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from 998082 to -267173 with 3 tasks modifies all indices...
+Verifying that push_loop() from 986466 to -642521 with 20 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from -779960 to 518984 with 4 tasks modifies all indices...
+Verifying that push_loop() from 994906 to -386703 with 7 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from -52424 to 2576 with 3 tasks modifies all indices...
+Verifying that push_loop() from -574578 to 327232 with 22 tasks modifies all indices...
 -> PASSED!
-Verifying that push_loop() from 131005 to -557044 with 10 tasks modifies all indices...
+Verifying that push_loop() from 632264 to 644863 with 12 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from -119788 to -727738 with 14 tasks modifies all indices...
+Verifying that parallelize_loop() from 450897 to -789636 with 16 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from -911425 to -923429 with 8 tasks modifies all indices...
+Verifying that parallelize_loop() from -986029 to -900579 with 24 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 49601 to -772605 with 16 tasks modifies all indices...
+Verifying that parallelize_loop() from -405930 to 299022 with 24 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from -322809 to -66366 with 15 tasks modifies all indices...
+Verifying that parallelize_loop() from -545956 to 219212 with 13 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 880099 to -150434 with 22 tasks modifies all indices...
+Verifying that parallelize_loop() from 462224 to 865745 with 26 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 984341 to 69159 with 11 tasks modifies all indices...
+Verifying that parallelize_loop() from -311718 to 644762 with 28 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from -207913 to 829987 with 9 tasks modifies all indices...
+Verifying that parallelize_loop() from -615396 to -267130 with 2 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 297749 to -332031 with 2 tasks modifies all indices...
+Verifying that parallelize_loop() from -510089 to 363393 with 26 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 517539 to 811728 with 8 tasks modifies all indices...
+Verifying that parallelize_loop() from -846318 to -18573 with 11 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 311585 to -81170 with 21 tasks modifies all indices...
+Verifying that parallelize_loop() from -680422 to -342474 with 23 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 670932 to 740527 with 3 tasks correctly sums all indices...
-Expected: 98230419510, obtained: 98230419510 -> PASSED!
-Verifying that parallelize_loop() from 645122 to -546036 with 11 tasks correctly sums all indices...
-Expected: 118025890430, obtained: 118025890430 -> PASSED!
-Verifying that parallelize_loop() from 251002 to -903037 with 6 tasks correctly sums all indices...
-Expected: -752474973404, obtained: -752474973404 -> PASSED!
-Verifying that parallelize_loop() from -222340 to -791805 with 15 tasks correctly sums all indices...
-Expected: -577520651890, obtained: -577520651890 -> PASSED!
-Verifying that parallelize_loop() from 937604 to 819765 with 3 tasks correctly sums all indices...
-Expected: 207086487752, obtained: 207086487752 -> PASSED!
-Verifying that parallelize_loop() from -53900 to -339294 with 24 tasks correctly sums all indices...
-Expected: -112215493830, obtained: -112215493830 -> PASSED!
-Verifying that parallelize_loop() from 65429 to 903556 with 22 tasks correctly sums all indices...
-Expected: 812131652968, obtained: 812131652968 -> PASSED!
-Verifying that parallelize_loop() from 519293 to -332413 with 19 tasks correctly sums all indices...
-Expected: 159165965574, obtained: 159165965574 -> PASSED!
-Verifying that parallelize_loop() from 165831 to 47482 with 18 tasks correctly sums all indices...
-Expected: 25245261888, obtained: 25245261888 -> PASSED!
-Verifying that parallelize_loop() from -534648 to 475350 with 13 tasks correctly sums all indices...
-Expected: -59891871402, obtained: -59891871402 -> PASSED!
+Verifying that parallelize_loop() from 383147 to -130987 with 10 tasks correctly sums all indices...
+Expected: 129643515306, obtained: 129643515306 -> PASSED!
+Verifying that parallelize_loop() from 827793 to 219417 with 18 tasks correctly sums all indices...
+Expected: 637096822584, obtained: 637096822584 -> PASSED!
+Verifying that parallelize_loop() from -441740 to -531834 with 12 tasks correctly sums all indices...
+Expected: -87713266050, obtained: -87713266050 -> PASSED!
+Verifying that parallelize_loop() from 980942 to 18492 with 2 tasks correctly sums all indices...
+Expected: 961904290850, obtained: 961904290850 -> PASSED!
+Verifying that parallelize_loop() from 351318 to 433401 with 8 tasks correctly sums all indices...
+Expected: 64412007594, obtained: 64412007594 -> PASSED!
+Verifying that parallelize_loop() from 184385 to 382813 with 30 tasks correctly sums all indices...
+Expected: 112547766316, obtained: 112547766316 -> PASSED!
+Verifying that parallelize_loop() from -498480 to 323830 with 10 tasks correctly sums all indices...
+Expected: -143617263810, obtained: -143617263810 -> PASSED!
+Verifying that parallelize_loop() from -119493 to 109088 with 25 tasks correctly sums all indices...
+Expected: -2378613886, obtained: -2378613886 -> PASSED!
+Verifying that parallelize_loop() from 776258 to 340877 with 6 tasks correctly sums all indices...
+Expected: 486378918054, obtained: 486378918054 -> PASSED!
+Verifying that parallelize_loop() from 160863 to 750589 with 3 tasks correctly sums all indices...
+Expected: 537506352426, obtained: 537506352426 -> PASSED!
 Verifying that parallelize_loop() with identical start and end indices does nothing...
 -> PASSED!
 Trying parallelize_loop() with start and end indices of different types:
-Verifying that parallelize_loop() from -962605 to 21974 with 17 tasks modifies all indices...
+Verifying that parallelize_loop() from 838162 to 345683 with 13 tasks modifies all indices...
 -> PASSED!
 Trying the overloads for push_loop() and parallelize_loop() for the case where the first index is equal to 0:
-Verifying that push_loop() from 0 to 482251 with 7 tasks modifies all indices...
+Verifying that push_loop() from 0 to 15216 with 30 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 0 to 151431 with 1 task modifies all indices...
+Verifying that parallelize_loop() from 0 to 239084 with 5 tasks modifies all indices...
 -> PASSED!
-Verifying that parallelize_loop() from 0 to 806998 with 4 tasks correctly sums all indices...
-Expected: 651244965006, obtained: 651244965006 -> PASSED!
+Verifying that parallelize_loop() from 0 to -824186 with 18 tasks correctly sums all indices...
+Expected: -679283386782, obtained: -679283386782 -> PASSED!
 
 ====================================
 Checking that task monitoring works:
@@ -1232,46 +1363,52 @@ Resetting pool to 4 threads.
 Submitting 12 tasks.
 After submission, should have: 12 tasks total, 4 tasks running, 8 tasks queued...
 Result: 12 tasks total, 4 tasks running, 8 tasks queued -> PASSED!
+Task 3 released.
 Task 1 released.
 Task 2 released.
-Task 3 released.
 Task 0 released.
 After releasing 4 tasks, should have: 8 tasks total, 4 tasks running, 4 tasks queued...
 Result: 8 tasks total, 4 tasks running, 4 tasks queued -> PASSED!
-Task 5 released.
 Task 4 released.
-Task 7 released.
 Task 6 released.
+Task 5 released.
+Task 7 released.
 After releasing 4 more tasks, should have: 4 tasks total, 4 tasks running, 0 tasks queued...
 Result: 4 tasks total, 4 tasks running, 0 tasks queued -> PASSED!
-Task 9 released.
-Task 11 released.
-Task 10 released.
 Task 8 released.
+Task 11 released.
+Task 9 released.
+Task 10 released.
 After releasing the final 4 tasks, should have: 0 tasks total, 0 tasks running, 0 tasks queued...
 Result: 0 tasks total, 0 tasks running, 0 tasks queued -> PASSED!
-Resetting pool to 24 threads.
+Resetting pool to 32 threads.
 
 ============================
 Checking that pausing works:
 ============================
 Resetting pool to 4 threads.
+Checking that the pool correctly reports that it is not paused.
+-> PASSED!
 Pausing pool.
+Checking that the pool correctly reports that it is paused.
+-> PASSED!
 Submitting 12 tasks, each one waiting for 200ms.
 Immediately after submission, should have: 12 tasks total, 0 tasks running, 12 tasks queued...
 Result: 12 tasks total, 0 tasks running, 12 tasks queued -> PASSED!
 300ms later, should still have: 12 tasks total, 0 tasks running, 12 tasks queued...
 Result: 12 tasks total, 0 tasks running, 12 tasks queued -> PASSED!
 Unpausing pool.
+Checking that the pool correctly reports that it is not paused.
+-> PASSED!
 Task 3 done.
-Task 1 done.
 Task 2 done.
+Task 1 done.
 Task 0 done.
 300ms later, should have: 8 tasks total, 4 tasks running, 4 tasks queued...
 Result: 8 tasks total, 4 tasks running, 4 tasks queued -> PASSED!
 Pausing pool and using wait_for_tasks() to wait for the running tasks.
-Task 4 done.
 Task 6 done.
+Task 4 done.
 Task 7 done.
 Task 5 done.
 After waiting, should have: 4 tasks total, 0 tasks running, 4 tasks queued...
@@ -1279,13 +1416,13 @@ Result: 4 tasks total, 0 tasks running, 4 tasks queued -> PASSED!
 200ms later, should still have: 4 tasks total, 0 tasks running, 4 tasks queued...
 Result: 4 tasks total, 0 tasks running, 4 tasks queued -> PASSED!
 Unpausing pool and using wait_for_tasks() to wait for all tasks.
-Task 9 done.
-Task 8 done.
-Task 10 done.
 Task 11 done.
+Task 9 done.
+Task 10 done.
+Task 8 done.
 After waiting, should have: 0 tasks total, 0 tasks running, 0 tasks queued...
 Result: 0 tasks total, 0 tasks running, 0 tasks queued -> PASSED!
-Resetting pool to 24 threads.
+Resetting pool to 32 threads.
 
 =======================================
 Checking that exception handling works:
@@ -1301,64 +1438,82 @@ Throwing exception...
 ============================================================
 Testing that vector operations produce the expected results:
 ============================================================
-Adding two vectors with 767202 elements using 4 tasks...
+Adding two vectors with 365392 elements using 9 tasks...
 -> PASSED!
-Adding two vectors with 3575 elements using 3 tasks...
+Adding two vectors with 797060 elements using 7 tasks...
 -> PASSED!
-Adding two vectors with 392555 elements using 11 tasks...
+Adding two vectors with 159148 elements using 19 tasks...
 -> PASSED!
-Adding two vectors with 754640 elements using 16 tasks...
+Adding two vectors with 432461 elements using 3 tasks...
 -> PASSED!
-Adding two vectors with 516335 elements using 9 tasks...
+Adding two vectors with 907909 elements using 30 tasks...
 -> PASSED!
-Adding two vectors with 564723 elements using 17 tasks...
+Adding two vectors with 854259 elements using 3 tasks...
 -> PASSED!
-Adding two vectors with 558475 elements using 15 tasks...
+Adding two vectors with 238088 elements using 2 tasks...
 -> PASSED!
-Adding two vectors with 447497 elements using 21 tasks...
+Adding two vectors with 559647 elements using 32 tasks...
 -> PASSED!
-Adding two vectors with 121486 elements using 19 tasks...
+Adding two vectors with 473570 elements using 25 tasks...
 -> PASSED!
-Adding two vectors with 324254 elements using 24 tasks...
+Adding two vectors with 124722 elements using 9 tasks...
 -> PASSED!
 
 ++++++++++++++++++++++++++++++
-SUCCESS: Passed all 85 checks!
+SUCCESS: Passed all 93 checks!
 ++++++++++++++++++++++++++++++
 ```
 
 ### Performance tests
 
-If all checks passed, `BS_thread_pool_test.cpp` will perform simple benchmarks by filling a specific number of vectors of fixed size with random values. The program decides how many vectors to use by testing how many are needed to reach a target duration in the single-threaded test. This ensures that the test takes approximately the same amount of time on different systems, and is thus more consistent and portable.
+If all checks passed, `BS_thread_pool_test.cpp` will perform simple benchmarks by filling a specific number of vectors of fixed size with values. The program decides how many vectors to use by testing how many are needed to reach a target duration in the single-threaded test. This ensures that the test takes approximately the same amount of time on different systems, and is thus more consistent and portable.
 
 Once the required number of vectors has been determined, the program will test the performance of several multi-threaded tests, dividing the total number of vectors into different numbers of tasks, compare them to the performance of the single-threaded test, and indicate the maximum speedup obtained.
 
-Please note that these benchmarks are only intended to demonstrate that the package can provide a significant speedup, and it is highly recommended to perform your own benchmarks with your specific system, compiler, and code.
-
-Here we will present the results of the performance test running on a high-end desktop computer equipped with a 12-core / 24-thread AMD Ryzen 9 3900X CPU at 3.8 GHz and 32 GB of DDR4 RAM at 3600 MHz, compiled using [MSVC](https://docs.microsoft.com/en-us/cpp/) v19.32.31332 on Windows 11 build 22000.795 with the `/O2` compiler flag. The output was as follows:
+As an example, here are the results of the benchmarks from a [Digital Research Alliance of Canada](https://alliancecan.ca/en) node equipped with two 20-core / 40-thread Intel Xeon Gold 6148 CPUs (for a total of 40 cores and 80 threads), running CentOS Linux 7.9.2009. The tests were compiled using GCC v12.2.0 with the `-O3` and `-march=native` flags. The output was as follows:
 
 ```none
 ======================
 Performing benchmarks:
 ======================
-Using 24 threads.
+Using 80 threads.
 Each test will be repeated 20 times to collect reliable statistics.
-Determining the number and size of vectors to generate in order to achieve an approximate mean execution time of 50 ms with 24 tasks...
-Generating 3312 vectors with 4096 elements each:
-Single-threaded, mean execution time was  542.2 ms with standard deviation  5.8 ms.
-With    6 tasks, mean execution time was   95.2 ms with standard deviation  1.7 ms.
-With   12 tasks, mean execution time was   49.6 ms with standard deviation  0.7 ms.
-With   24 tasks, mean execution time was   29.0 ms with standard deviation  2.9 ms.
-With   48 tasks, mean execution time was   33.2 ms with standard deviation  4.3 ms.
-With   96 tasks, mean execution time was   35.5 ms with standard deviation  1.9 ms.
-Maximum speedup obtained by multithreading vs. single-threading: 18.7x, using 24 tasks.
+Determining the number and size of vectors to generate in order to achieve an approximate mean execution time of 50 ms with 80 tasks...
+Generating 4000 vectors with 5120 elements each:
+Single-threaded, mean execution time was 2211.9 ms with standard deviation 39.1 ms.
+With   20 tasks, mean execution time was  128.8 ms with standard deviation 12.8 ms.
+With   40 tasks, mean execution time was   71.6 ms with standard deviation  1.1 ms.
+With   80 tasks, mean execution time was   44.4 ms with standard deviation  5.0 ms.
+With  160 tasks, mean execution time was   47.0 ms with standard deviation  6.4 ms.
+With  320 tasks, mean execution time was  132.6 ms with standard deviation  2.2 ms.
+Maximum speedup obtained by multithreading vs. single-threading: 49.8x, using 80 tasks.
 
 +++++++++++++++++++++++++++++++++++++++
 Thread pool performance test completed!
 +++++++++++++++++++++++++++++++++++++++
 ```
 
-This CPU has 12 physical cores, with each core providing two separate logical cores via hyperthreading, for a total of 24 threads. Without hyperthreading, we would expect a maximum theoretical speedup of 12x. With hyperthreading, one might naively expect to achieve up to a 24x speedup, but this is in fact impossible, as both logical cores share the same physical core's resources. However, generally we would expect [an estimated 30% additional speedup](https://software.intel.com/content/www/us/en/develop/articles/how-to-determine-the-effectiveness-of-hyper-threading-technology-with-an-application.html) from hyperthreading, which amounts to around 15.6x in this case. In our performance test, we see a speedup of 18.7x, saturating and even surpassing this estimated theoretical upper bound.
+These two CPUs have 40 physical cores in total, with each core providing two separate logical cores via hyperthreading, for a total of 80 threads. Without hyperthreading, we would expect a maximum theoretical speedup of 40x. With hyperthreading, one might naively expect to achieve up to an 80x speedup, but this is in fact impossible, as each pair of hyperthreaded logical cores share the same physical core's resources. However, generally we would expect at most an estimated 30% additional speedup from hyperthreading, which amounts to around 52x in this case. The speedup of 49.8x in our performance test is very close to this estimate.
+
+In addition, this test demonstrates that splitting the loop into a number of tasks to be equal to the number of hardware threads usually yields optimal results, since all the tasks can be run in parallel. When we used less than 80 tasks, not all of the CPU cores were taken advantage of, and when we used more than 80 tasks, they had to run in more than one batch instead of all at once, introducing additional overhead.
+
+## The light version of the package
+
+This package started out as a very lightweight C++ thread pool, but over time has expanded to include many additional features and helper classes. Therefore, I have decided to bundle a light version of the thread pool in a separate and stand-alone header file, `BS_thread_pool_light.hpp`, which is about half the size of the full package.
+
+This file does not contain any of the helper classes, only a new `BS::thread_pool_light` class, which is a minimal thread pool with only the 5 most basic member functions:
+
+* `get_thread_count()`
+* `push_loop()`
+* `push_task()`
+* `submit()`
+* `wait_for_tasks()`
+
+A separate test program `BS_thread_pool_light_test.cpp` tests only the features of the lightweight `BS::thread_pool_light` class. In the spirit of minimalism, it does not generate a log file and does not do any benchmarks.
+
+To be perfectly clear, each header file is 100% stand-alone. If you wish to use the full package, you only need `BS_thread_pool.hpp`, and if you wish to use the light version, you only need `BS_thread_pool_light.hpp`. Only a single header file needs to be included in your project. However, if you wish to use both the light and non-light thread pool classes in the same project, you can include both header files.
+
+If needed, the current version of the light thread pool can be obtained using the macro `BS_THREAD_POOL_LIGHT_VERSION`.
 
 ## About the project
 
@@ -1378,9 +1533,9 @@ If you found this project useful, please consider [starring it on GitHub](https:
 
 ### Copyright and citing
 
-Copyright (c) 2022 [Barak Shoshany](http://baraksh.com). Licensed under the [MIT license](LICENSE.txt).
+Copyright (c) 2023 [Barak Shoshany](http://baraksh.com). Licensed under the [MIT license](LICENSE.txt).
 
-If you use the library in software of any kind, please provide a link to [the GitHub repository](https://github.com/bshoshany/thread-pool) in the source code and documentation.
+If you use this C++ thread pool library in software of any kind, please provide a link to [the GitHub repository](https://github.com/bshoshany/thread-pool) in the source code and documentation.
 
 If you use this library in published research, please cite it as follows: