Updated list of supported implementations

Changed status to "Under development and not yet ready for production
use".

Updated Compiler Explorer example to not use std::jthread since that is
missing in libc++ and to not use chrono operator<< overloads to display
durations since some of the older implementations that this library
support have not implemented those overloads. Made the same adjustments
to the test and example code.

Updated the CI workflows so they don't try to use ThreadSanitizer when
using libstdc++ versions that won't compile when using std::timed_mutex.
Also removed compiling in C++17 mode for now. It should be be easy to
replace the concepts with old-school type traits if needed.

Signed-off-by: Ted Lyngmo <[email protected]>

Author: TedLyngmo

.github/workflows/ci_tests.yml

@@ -42,29 +42,29 @@ jobs:
                   "tests": [
                     { "stdlibs": ["libstdc++"],
                       "tests": [
-                        "Debug.Default", "Release.Default", "Release.TSan",
+                        "Debug.Default", "Release.Default",
                         "Release.MaxSan", "Debug.Werror", "Debug.Dynamic",
                         "Debug.Coverage"
                       ]
                     }
                   ]
                 },
-                { "cxxversions": ["c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++23", "c++20"],
                   "tests": [{ "stdlibs": ["libstdc++"], "tests": ["Release.Default"]}]
                 }
               ]
             },
             { "versions": ["14", "13"],
               "tests": [
-                { "cxxversions": ["c++26", "c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++26", "c++23", "c++20"],
                   "tests": [{ "stdlibs": ["libstdc++"], "tests": ["Release.Default"]}]
                 }
               ]
             },
             {
               "versions": ["12", "11"],
               "tests": [
-                { "cxxversions": ["c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++23", "c++20"],
                   "tests": [{ "stdlibs": ["libstdc++"], "tests": ["Release.Default"]}]
                 }
               ]
@@ -75,15 +75,21 @@ jobs:
               "tests": [
                 {"cxxversions": ["c++26"],
                   "tests": [
-                    { "stdlibs": ["libstdc++", "libc++"],
+                    { "stdlibs": ["libc++"],
                       "tests": [
                         "Debug.Default", "Release.Default", "Release.TSan",
                         "Release.MaxSan", "Debug.Werror", "Debug.Dynamic"
                       ]
+                    },
+                    { "stdlibs": ["libstdc++"],
+                      "tests": [
+                        "Debug.Default", "Release.Default",
+                        "Release.MaxSan", "Debug.Werror", "Debug.Dynamic"
+                      ]
                     }
                   ]
                 },
-                { "cxxversions": ["c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++23", "c++20"],
                   "tests": [
                     {"stdlibs": ["libstdc++", "libc++"], "tests": ["Release.Default"]}
                   ]
@@ -92,7 +98,7 @@ jobs:
             },
             { "versions": ["20", "19", "18"],
               "tests": [
-                { "cxxversions": ["c++26", "c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++26", "c++23", "c++20"],
                   "tests": [
                     {"stdlibs": ["libstdc++", "libc++"], "tests": ["Release.Default"]}
                   ]
@@ -101,10 +107,10 @@ jobs:
             },
             { "versions": ["17"],
               "tests": [
-                { "cxxversions": ["c++26", "c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++26", "c++23", "c++20"],
                   "tests": [{"stdlibs": ["libc++"], "tests": ["Release.Default"]}]
                 },
-                { "cxxversions": ["c++20", "c++17"],
+                { "cxxversions": ["c++20"],
                   "tests": [{"stdlibs": ["libstdc++"], "tests": ["Release.Default"]}]
                 }
               ]
@@ -113,7 +119,7 @@ jobs:
           "appleclang": [
             { "versions": ["latest"],
               "tests": [
-                { "cxxversions": ["c++26", "c++23", "c++20", "c++17"],
+                { "cxxversions": ["c++26", "c++23", "c++20"],
                   "tests": [{ "stdlibs": ["libc++"], "tests": ["Release.Default"]}]
                 }
               ]

README.md

@@ -5,13 +5,13 @@ SPDX-License-Identifier: MIT
 -->
 
 <!-- markdownlint-disable-next-line line-length -->
-![Library Status](https://raw.githubusercontent.com/bemanproject/beman/refs/heads/main/images/badges/beman_badge-beman_library_production_ready_api_may_undergo_changes.svg) ![Continuous Integration Tests](https://github.com/bemanproject/timed_lock_alg/actions/workflows/ci_tests.yml/badge.svg) ![Lint Check (pre-commit)](https://github.com/bemanproject/timed_lock_alg/actions/workflows/pre-commit-check.yml/badge.svg) [![Coverage](https://coveralls.io/repos/github/bemanproject/timed_lock_alg/badge.svg?branch=main)](https://coveralls.io/github/bemanproject/timed_lock_alg?branch=main) ![Standard Target](https://github.com/bemanproject/beman/blob/main/images/badges/cpp29.svg) [![Compiler Explorer Example](https://img.shields.io/badge/Try%20it%20on%20Compiler%20Explorer-grey?logo=compilerexplorer&logoColor=67c52a)](https://godbolt.org/z/3reh77M53)
+![Library Status](https://github.com/bemanproject/beman/blob/main/images/badges/beman_badge-beman_library_under_development.svg) ![Continuous Integration Tests](https://github.com/bemanproject/timed_lock_alg/actions/workflows/ci_tests.yml/badge.svg) ![Lint Check (pre-commit)](https://github.com/bemanproject/timed_lock_alg/actions/workflows/pre-commit-check.yml/badge.svg) [![Coverage](https://coveralls.io/repos/github/bemanproject/timed_lock_alg/badge.svg?branch=main)](https://coveralls.io/github/bemanproject/timed_lock_alg?branch=main) ![Standard Target](https://github.com/bemanproject/beman/blob/main/images/badges/cpp29.svg) [![Compiler Explorer Example](https://img.shields.io/badge/Try%20it%20on%20Compiler%20Explorer-grey?logo=compilerexplorer&logoColor=67c52a)](https://godbolt.org/z/jPYdxT3E7)
 
 `beman.timed_lock_alg` implements timed lock algorithms for multiple lockables.
 
 **Implements**: `std::try_lock_until` and `std::try_lock_for` proposed in [Timed lock algorithms for multiple lockables (P3832R0)](https://wg21.link/P3832R0).
 
-**Status**: [Production ready. API may undergo changes.](https://github.com/bemanproject/beman/blob/main/docs/beman_library_maturity_model.md#production-ready-api-may-undergo-changes)
+**Status**: [Under development and not yet ready for production use.](https://github.com/bemanproject/beman/blob/main/docs/beman_library_maturity_model.md#under-development-and-not-yet-ready-for-production-use)
 
 ## License
 
@@ -49,30 +49,16 @@ You can disable building tests by setting CMake option
 [`BEMAN_TIMED_LOCK_ALG_BUILD_TESTS`](#beman_timed_lock_alg_build_tests) to `OFF`
 when configuring the project.
 
-> [!TIP]
->
-> The logs indicate examples disabled due to lack of compiler support.
->
-> For example:
->
-> ```txt
-> -- Looking for __cpp_lib_ranges
-> -- Looking for __cpp_lib_ranges - not found
-> CMake Warning at examples/CMakeLists.txt:12 (message):
->   Missing range support! Skip: identity_as_default_projection
->
->
-> Examples to be built: identity_direct_usage
-> ```
-
 ### Supported Platforms
 
 This project officially supports:
 
-* GCC versions 11–15
-* LLVM Clang++ (with libstdc++ or libc++) versions 17–21
+* GCC versions 10–15
+* LLVM Clang++ (with libstdc++ or libc++) versions 11–21
+* ICX (with libstdc++ or libc++) versions 2021.1.2-2025.2.1
 * AppleClang version 17.0.0 (i.e., the [latest version on GitHub-hosted macOS runners](https://github.com/actions/runner-images/blob/main/images/macos/macos-15-arm64-Readme.md))
-* MSVC version 19.44.35215.0 (i.e., the [latest version on GitHub-hosted Windows runners](https://github.com/actions/runner-images/blob/main/images/windows/Windows2022-Readme.md))
+* MSVC version 19.29 (with `/std:c++latest`) and 19.30 to 19.44.35215.0 (i.e., the [latest version on GitHub-hosted Windows runners](https://github.com/actions/runner-images/blob/main/images/windows/Windows2022-Readme.md))
+* Note: libstdc++ versions 14-14.3 and 15-15.2 (inclusive) does _not_ support using `-fsanitize=thread` on code using `std::timed_mutex` due to [Bug 121496](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121496). This affects GCC and all implementations using libstdc++ such as LLVM Clang++ and ICX unless `-stdlib=libc++` is used.
 
 > [!NOTE]
 >

examples/try_lock_a_bunch.cpp

@@ -9,6 +9,20 @@
 #include <iostream>
 #include <thread>
 
+namespace {
+// joining thread for implementations missing std::jthread
+class JThread : public std::thread {
+  public:
+    template <class... Args>
+    JThread(Args&&... args) : std::thread(std::forward<Args>(args)...) {}
+    ~JThread() {
+        if (joinable()) {
+            join();
+        }
+    }
+};
+} // namespace
+
 namespace tla = beman::timed_lock_alg;
 
 constexpr std::chrono::milliseconds yield(10);
@@ -25,23 +39,24 @@ int main() {
     for (int ms = 10; ms <= 70; ms += 20) { // try 10, 30, 50, 70 ms
         std::chrono::milliseconds cms(ms);
         // start a thread that locks the last mutex unless mtxs is empty
-        std::jthread jt = [&]() -> std::jthread {
+        JThread jt = [&]() -> JThread {
             if constexpr (not mtxs.empty()) {
-                return std::jthread(foo, std::ref(mtxs.back()));
+                return JThread(foo, std::ref(mtxs.back()));
             } else {
                 return {};
             }
         }();
         std::this_thread::sleep_for(yield);
 
-        std::cout << "trying for " << cms << '\n';
+        std::cout << "trying for " << cms.count() << "ms\n";
 
         auto start = std::chrono::steady_clock::now();
         auto r1    = std::apply([&](auto&... mxs) { return tla::try_lock_for(cms, mxs...); }, mtxs);
         auto end   = std::chrono::steady_clock::now();
 
         // should be done in approx. 10, 30, 40 and 40 ms, where the two last tries succeeds:
-        std::cout << "done in " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start) << ": ";
+        std::cout << "done in " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
+                  << "ms: ";
 
         if (r1 == -1) {
             auto sl = std::apply([&](auto&... mxs) { return std::scoped_lock(std::adopt_lock, mxs...); }, mtxs);

tests/beman/timed_lock_alg/mutex.test.cpp

@@ -14,6 +14,17 @@ using namespace std::chrono_literals;
 namespace tla = beman::timed_lock_alg;
 
 namespace {
+// joining thread for implementations missing std::jthread
+class JThread : public std::thread {
+  public:
+    template <class... Args>
+    JThread(Args&&... args) : std::thread(std::forward<Args>(args)...) {}
+    ~JThread() {
+        if (joinable()) {
+            join();
+        }
+    }
+};
 const auto now         = std::chrono::steady_clock::now();
 const auto no_duration = std::chrono::milliseconds{0};
 
@@ -50,7 +61,7 @@ TEST(Mutex, try_many_unlocked) {
 
 TEST(Mutex, try_many_one_locked) {
     std::array<std::timed_mutex, 30> mtxs;
-    auto                             th = std::jthread([&] {
+    auto                             th = JThread([&] {
         std::lock_guard lg(mtxs.back());
         std::this_thread::sleep_for(15ms);
     });
@@ -63,7 +74,7 @@ TEST(Mutex, try_many_one_locked) {
 
 TEST(Mutex, return_last_failed) {
     std::array<std::timed_mutex, 2> mtxs;
-    auto                            th = std::jthread([&] {
+    auto                            th = JThread([&] {
         std::lock(mtxs[0], mtxs[1]);
         std::this_thread::sleep_for(10ms);
         mtxs[0].unlock(); // 5ms after try_lock_for started, 15ms left
@@ -82,7 +93,7 @@ TEST(Mutex, succeed_with_three_in_tricky_sequence) {
     // A different implementation may behave differently but should
     // still succeed in locking all three in time.
     std::array<std::timed_mutex, 3> mtxs;
-    auto                            th = std::jthread([&] {
+    auto                            th = JThread([&] {
         std::lock(mtxs[0], mtxs[1], mtxs[2]);
         std::this_thread::sleep_for(10ms);
         mtxs[0].unlock(); // 5ms after try_lock_for started, 15ms left
@@ -97,5 +108,6 @@ TEST(Mutex, succeed_with_three_in_tricky_sequence) {
     });
 
     std::this_thread::sleep_for(5ms);
-    EXPECT_EQ(-1, std::apply([](auto&... mts) { return tla::try_lock_for(20ms, mts...); }, mtxs));
+    // 20ms is enough for most implementations, but lets give MSVC 10ms more
+    EXPECT_EQ(-1, std::apply([](auto&... mts) { return tla::try_lock_for(20ms + 10ms, mts...); }, mtxs));
 }