Add support for using this thread pool with coroutines

.cmake-format

@@ -2,6 +2,7 @@ format:
   tab_size: 4
   line_width: 100
   dangle_parens: true
+  max_pargs_hwrap: 4
 
 parse:
   additional_commands:

.github/workflows/style.yml

@@ -29,7 +29,7 @@ jobs:
           pip3 install cmake_format==0.6.11 pyyaml
 
       - name: configure
-        run: cmake -G Ninja -S . -B build -DTP_BUILD_EXAMPLES=OFF
+        run: cmake -G Ninja -S . -B build -DTP_BUILD_EXAMPLES=OFF -DTP_BUILD_BENCHMARKS=OFF
 
       - name: check style
         run: cmake --build build --target check-format

.github/workflows/ubuntu.yml

@@ -33,7 +33,7 @@ jobs:
       - name: Set up Clang
         uses: egor-tensin/setup-clang@v1
         with:
-          version: 13
+          version: 14
           platform: x64
 
       - name: set up GCC

.gitignore

@@ -5,3 +5,5 @@
 .vs
 out
 CMakeFiles
+.idea
+cmake-build*

CMakeLists.txt

@@ -1,8 +1,5 @@
 cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 
-# ---- Project ----
-
-# Note: update this to your new project's name and version
 project(
     ThreadPool
     VERSION 0.4.1
@@ -19,9 +16,14 @@ if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
     )
 endif()
 
+find_program(CCACHE_EXE ccache)
+if(EXISTS ${CCACHE_EXE})
+    message(STATUS "Found ccache ${CCACHE_EXE}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_EXE})
+endif()
+
 # ---- Add dependencies via CPM ----
 # see https://github.com/TheLartians/CPM.cmake for more info
-
 include(cmake/CPM.cmake)
 
 # PackageProject.cmake will be used to make our target installable
@@ -60,6 +62,12 @@ target_link_libraries(${PROJECT_NAME} INTERFACE Threads::Threads)
 
 # being a cross-platform target, we enforce standards conformance on MSVC
 target_compile_options(${PROJECT_NAME} INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/permissive->")
+target_compile_options(${PROJECT_NAME} INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,GNU>:-fcoroutines>")
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++")
+endif()
 
 target_include_directories(
     ${PROJECT_NAME} INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>

README.md

@@ -4,6 +4,8 @@ thread-pool
 
 [![say thanks](https://img.shields.io/badge/Say%20Thanks-👍-1EAEDB.svg)](https://github.com/DeveloperPaul123/periodic-function/stargazers)
 [![Discord](https://img.shields.io/discord/652515194572111872)](https://discord.gg/CX2ybByRnt)
+![License](https://img.shields.io/github/license/DeveloperPaul123/thread-pool?color=blue)
+![Release](https://img.shields.io/github/v/release/DeveloperPaul123/thread-pool)
 
 [![Ubuntu](https://github.com/DeveloperPaul123/thread-pool/actions/workflows/ubuntu.yml/badge.svg)](https://github.com/DeveloperPaul123/thread-pool/actions/workflows/ubuntu.yml)
 [![Windows](https://github.com/DeveloperPaul123/thread-pool/actions/workflows/windows.yml/badge.svg)](https://github.com/DeveloperPaul123/thread-pool/actions/workflows/windows.yml)
@@ -80,12 +82,12 @@ See the `./benchmark` folder for the benchmark code. The benchmarks are set up t
 Matrix sizes are all square (MxM). Each multiplication is `(MxM) * (MxM)` where `*` refers to a matrix multiplication operation. Times recorded were the best of at least 3 runs.
 
 | Matrix Size | Number of multiplications | `std::async` time (ms) | `dp::thread_pool` time (ms) |
-|:---:|:---:|:---:|:---:|
-| 8 | 25,000 | 77.9 | 65.3 |
-| 64 | 5,000 | 100 | 65.2 |
-| 256 | 250 | 295 | 59.2 |
-| 512 | 75 | 713 | 60.4 |
-| 1024 | 10 | 1160 | 55.8 |
+|:-----------:|:-------------------------:|:----------------------:|:---------------------------:|
+|      8      |          25,000           |          77.9          |            65.3             |
+|     64      |           5,000           |          100           |            65.2             |
+|     256     |            250            |          295           |            59.2             |
+|     512     |            75             |          713           |            60.4             |
+|    1024     |            10             |          1160          |            55.8             |
 
 ## Building
 
@@ -105,10 +107,10 @@ cmake --build build
 
 ### Build Options
 
-| Option | Description | Default |
-|:-------|:------------|:--------:|
-| `TP_BUILD_TESTS` | Turn on to build unit tests. Required for formatting build targets. | ON |
-| `TP_BUILD_EXAMPLES` | Turn on to build examples | ON |
+| Option              | Description                                                         | Default |
+|:--------------------|:--------------------------------------------------------------------|:-------:|
+| `TP_BUILD_TESTS`    | Turn on to build unit tests. Required for formatting build targets. |   ON    |
+| `TP_BUILD_EXAMPLES` | Turn on to build examples                                           |   ON    |
 
 ### Run clang-format
 

benchmark/CMakeLists.txt

@@ -12,7 +12,14 @@ CPMAddPackage(
     NAME benchmark
     GITHUB_REPOSITORY google/benchmark
     VERSION 1.6.1
-    OPTIONS "BENCHMARK_ENABLE_TESTING OFF"
+    OPTIONS "BENCHMARK_ENABLE_TESTING OFF" "CMAKE_CROSSCOMPILING ON" "HAVE_STD_REGEX OFF"
+            "HAVE_POSIX_REGEX OFF"
+)
+
+CPMAddPackage(
+    NAME cppcoro
+    GITHUB_REPOSITORY andreasbuhr/cppcoro
+    GIT_TAG 10bbcdbf2be3ad3aa56febcf4c7662d771460a99
 )
 
 if(benchmark_ADDED)
@@ -26,7 +33,7 @@ file(GLOB sources CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp)
 file(GLOB headers CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)
 
 add_executable(${PROJECT_NAME} ${headers} ${sources})
-target_link_libraries(${PROJECT_NAME} benchmark ThreadPool::ThreadPool)
+target_link_libraries(${PROJECT_NAME} benchmark ThreadPool::ThreadPool cppcoro)
 set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 20)
 target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
 

benchmark/include/utilities.h

@@ -2,11 +2,14 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cppcoro/task.hpp>
 #include <iterator>
 #include <random>
 #include <span>
 #include <vector>
 
+#include "thread_pool/thread_pool.h"
+
 inline std::size_t index(std::size_t row, std::size_t col, std::size_t width) {
     return row * width + col;
 }
@@ -22,6 +25,12 @@ inline void multiply_array(std::span<int> a, std::span<int> b, std::span<int> re
     }
 }
 
+inline cppcoro::task<> co_multiply_array(std::span<int> a, std::span<int> b, std::span<int> result,
+                                         dp::thread_pool<>& pool) {
+    co_await pool.schedule();
+    multiply_array(a, b, result);
+}
+
 template <typename T>
 using multiplication_pair = std::pair<std::vector<T>, std::vector<T>>;
 
@@ -30,6 +39,7 @@ template <typename T>
     const std::int64_t& array_size, const std::int64_t& number_of_multiplications) {
     static std::uniform_int_distribution<T> distribution(std::numeric_limits<T>::min(),
                                                          std::numeric_limits<T>::max());
+    // yes, predictable values
     static std::default_random_engine generator{};
 
     std::vector<multiplication_pair<T>> computations;

benchmark/source/thread_pool.cpp

@@ -1,9 +1,12 @@
 #include <benchmark/benchmark.h>
 #include <thread_pool/thread_pool.h>
 
+#include <cppcoro/sync_wait.hpp>
+#include <cppcoro/when_all.hpp>
+
 #include "utilities.h"
 
-static void BM_array_multiplication(benchmark::State& state) {
+static void BM_array_multiplication_thread_pool(benchmark::State& state) {
     const auto array_size = state.range(0);
     const std::size_t multiplications_to_perform = state.range(1);
 
@@ -28,14 +31,100 @@ static void BM_array_multiplication(benchmark::State& state) {
     }
 }
 
-BENCHMARK(BM_array_multiplication)
+BENCHMARK(BM_array_multiplication_thread_pool)
+#if defined(NDEBUG)
     ->Args({8, 25'000})
     ->Args({64, 5'000})
     ->Args({256, 250})
     ->Args({512, 75})
     ->Args({1024, 10})
+#else
+    ->Args({8, 50})
+#endif
     ->Unit(benchmark::kMillisecond)
     ->ReportAggregatesOnly(true)
     ->MeasureProcessCPUTime()
     ->UseRealTime()
     ->Name("dp::thread_pool array mult");
+
+static void BM_array_multiplication_batch_thread_pool(benchmark::State& state) {
+    const auto array_size = state.range(0);
+    const std::size_t multiplications_to_perform = state.range(1);
+
+    // generate the data
+    const auto computations = generate_benchmark_data<int>(array_size, multiplications_to_perform);
+
+    // create our tasks
+    std::vector<std::function<void()>> tasks{};
+    tasks.reserve(computations.size());
+
+    // task that is run on a new thread
+    auto thread_task = [](multiplication_pair<int> pair) {
+        std::vector<int> result(pair.first.size());
+        multiply_array(pair.first, pair.second, result);
+    };
+
+    for (const auto& computation : computations) {
+        auto task = [comp = computation, execution_task = thread_task]() { execution_task(comp); };
+        tasks.emplace_back(task);
+    }
+
+    // create our thread pool using the default size
+    dp::thread_pool pool{};
+
+    for (auto _ : state) {
+        pool.enqueue(tasks.begin(), tasks.end());
+    }
+}
+
+BENCHMARK(BM_array_multiplication_batch_thread_pool)
+#if defined(NDEBUG)
+    ->Args({8, 25'000})
+    ->Args({64, 5'000})
+    ->Args({256, 250})
+    ->Args({512, 75})
+    ->Args({1024, 10})
+#else
+    ->Args({8, 50})
+#endif
+    ->Unit(benchmark::kMillisecond)
+    ->ReportAggregatesOnly(true)
+    ->MeasureProcessCPUTime()
+    ->UseRealTime()
+    ->Name("dp::thread_pool batched array mult");
+
+inline cppcoro::task<void> mult_task(multiplication_pair<int> pair, dp::thread_pool<>& pool) {
+    std::vector<int> result(pair.first.size());
+    co_await co_multiply_array(pair.first, pair.second, result, pool);
+}
+
+static void BM_array_multiplication_thread_pool_coroutine(benchmark::State& state) {
+    const auto array_size = state.range(0);
+    const std::size_t multiplications_to_perform = state.range(1);
+    const auto computations = generate_benchmark_data<int>(array_size, multiplications_to_perform);
+    dp::thread_pool pool{};
+    std::vector<cppcoro::task<>> tasks;
+    for (auto _ : state) {
+        for (auto mult_pair : computations) {
+            tasks.emplace_back(mult_task(mult_pair, pool));
+        }
+    }
+
+    cppcoro::sync_wait(cppcoro::when_all(std::move(tasks)));
+}
+
+BENCHMARK(BM_array_multiplication_thread_pool_coroutine)
+#if defined(NDEBUG)
+    ->Args({8, 25'000})
+    ->Args({64, 5'000})
+    ->Args({256, 250})
+    ->Args({512, 75})
+    ->Args({1024, 10})
+#else
+    ->Args({8, 50})
+#endif
+    ->Unit(benchmark::kMillisecond)
+    ->ReportAggregatesOnly(true)
+    ->MeasureProcessCPUTime()
+    ->UseRealTime()
+    ->Name("dp::thread_pool coroutine array mult");

cmake/CPM.cmake

@@ -1,4 +1,4 @@
-set(CPM_DOWNLOAD_VERSION 0.32.0)
+set(CPM_DOWNLOAD_VERSION 0.35.6)
 
 if(CPM_SOURCE_CACHE)
     # Expand relative path. This is important if the provided path contains a tilde (~)