Add std::execution::par supplementation

Author: alugowski

.github/workflows/tests.yml

@@ -73,6 +73,8 @@ jobs:
           cmake --build build/ --config Debug
           cd build/tests
           ctest -C Debug --output-on-failure --verbose
+          echo "Supplement Test:"
+          ./supplement_test || ./Debug/supplement_test.exe
         shell: bash
 
       - name: Benchmark

README.md

@@ -37,7 +37,7 @@ int main() {
 
 ### Pool control
 
-Use `poolstl::par_pool` with your own [thread pool](https://github.com/alugowski/task-thread-pool) to have full control over thread count, thread startup, shut down, etc.:
+Use `poolstl::par_pool` with your own [thread pool](https://github.com/alugowski/task-thread-pool) to have full control over thread count, thread startup/shutdown, etc.:
 
 ```c++
 task_thread_pool::task_thread_pool pool;
@@ -47,6 +47,20 @@ std::for_each(poolstl::par_pool(pool), v.cbegin(), v.cbegin(), [](auto) {});
 
 The pool used by `poolstl::par` is managed internally by poolSTL. It is started on first use.
 
+## poolSTL as `std::execution::par` substitute
+**USE AT YOUR OWN RISK!**
+
+Two-line fix for missing compiler support. A no-op on compilers with support.
+
+If `POOLSTL_STD_SUPPLEMENT` is defined and native support is not found then poolSTL will alias its `poolstl::par` as `std::execution::par`:
+
+```c++
+#define POOLSTL_STD_SUPPLEMENT
+#include <poolstl/poolstl.hpp>
+```
+
+Now just use `std::execution::par` as normal. See [supplement_test.cpp](tests/supplement_test.cpp).
+
 ## Implemented algorithms
 Algorithms are added on an as-needed basis. If you need one that is not present feel free to open an issue or submit a PR.
 

include/poolstl/poolstl.hpp

@@ -18,4 +18,38 @@
 #include "algorithm"
 #include "numeric"
 
+/*
+ * Optionally alias poolstl::par as std::execution::par to enable poolSTL to fill in for missing compiler support.
+ *
+ * USE AT YOUR OWN RISK!
+ *
+ * To do this define POOLSTL_STD_SUPPLEMENT before including poolstl.hpp.
+ *
+ * This aliasing will not happen if native support exists. If this autodetection fails for you:
+ *   - define POOLSTL_ALLOW_SUPPLEMENT=0 to disable
+ *   - define POOLSTL_FORCE_SUPPLEMENT to force enable (use with great care!)
+ */
+#ifndef POOLSTL_ALLOW_SUPPLEMENT
+#define POOLSTL_ALLOW_SUPPLEMENT 1
+#endif
+
+#if POOLSTL_ALLOW_SUPPLEMENT && defined(POOLSTL_STD_SUPPLEMENT)
+
+#if __cplusplus >= 201603L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201603L)
+#if __has_include(<execution>)
+#include <execution>
+#endif
+#endif
+
+#if !defined(__cpp_lib_parallel_algorithm) || defined(POOLSTL_FORCE_SUPPLEMENT)
+namespace std {
+    namespace execution {
+        using ::poolstl::execution::parallel_policy;
+        using ::poolstl::execution::par;
+    }
+}
+
+#endif
+#endif
+
 #endif

tests/CMakeLists.txt

@@ -45,3 +45,19 @@ catch_discover_tests(poolstl_test)
 add_executable(cpp11_test cpp11_test.cpp)
 target_link_libraries(cpp11_test PUBLIC poolSTL::poolSTL)
 target_compile_features(cpp11_test PUBLIC cxx_std_11)
+
+# Test std::execution supplementation
+# This uses only std::execution::par. On compilers with support this should result in a poolSTL no-op,
+# and on ones without support it should use fallback to poolstl::par.
+add_executable(supplement_test supplement_test.cpp)
+target_link_libraries(supplement_test PUBLIC poolSTL::poolSTL)
+target_compile_features(supplement_test PUBLIC cxx_std_17)
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    # GCC and Clang require TBB for std::execution::par
+    find_package(TBB)
+    if (TBB_FOUND)
+        target_link_libraries(supplement_test PUBLIC TBB::tbb)
+    else()
+        message("No TBB")
+    endif()
+endif()

tests/supplement_test.cpp

@@ -0,0 +1,32 @@
+// Copyright (C) 2023 Adam Lugowski. All rights reserved.
+// Use of this source code is governed by:
+// the BSD 2-clause license, the MIT license, or at your choosing the BSL-1.0 license found in the LICENSE.*.txt files.
+// SPDX-License-Identifier: BSD-2-Clause OR MIT OR BSL-1.0
+
+#include <iostream>
+#include <numeric>
+
+// The <execution> header defines compiler-provided execution policies, but is not always present.
+#if __cplusplus >= 201603L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201603L)
+#if __has_include(<execution>)
+#include <execution>
+#endif
+#endif
+
+#define POOLSTL_STD_SUPPLEMENT
+#include <poolstl/poolstl.hpp>
+
+int main() {
+    if (std::is_same_v<std::execution::parallel_policy, poolstl::execution::parallel_policy>) {
+        std::cout << "Using poolSTL supplement" << std::endl;
+    } else {
+        std::cout << "Using native par" << std::endl;
+    }
+
+    std::vector<int> v = {0, 1, 2, 3, 4, 5};
+    std::for_each(std::execution::par, v.cbegin(), v.cend(), [](int x) {
+        std::cout << x << " ";
+    });
+    std::cout << std::endl;
+    return 0;
+}