Add multi_lock, P3833

TedLyngmo · TedLyngmo · commit c374eccad986 · 2025-11-18T21:48:39.000+01:00
Signed-off-by: Ted Lyngmo &lt;ted@lyncon.se&gt;
diff --git a/README.md b/README.md
@@ -7,9 +7,9 @@ SPDX-License-Identifier: MIT
 <!-- markdownlint-disable-next-line line-length -->
 ![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.
+`beman.timed_lock_alg` implements timed lock algorithms for multiple lockables and `std::multi_lock`.
 
-**Implements**: `std::try_lock_until` and `std::try_lock_for` proposed in [Timed lock algorithms for multiple lockables (P3832R0)](https://wg21.link/P3832R0).
+**Implements**: `std::try_lock_until` and `std::try_lock_for` proposed in [Timed lock algorithms for multiple lockables (P3832R0)](https://wg21.link/P3832R0) and `std::multi_lock` proposed in [`std::multi_lock` (P3833R0)](https://wg21.link/P3832R0)
 
 **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)
 
@@ -33,6 +33,17 @@ if (std::try_lock_for(100ms, m1, m2) == -1) {
 }
 ```
 
+`std::multi_lock` is a flexible RAII container usable with zero to many _BasicLockables_.
+
+Example:
+```
+std::timed_mutex m1, m2;
+std::multi_lock lock(100ms, m1, m2);
+if (lock) {
+    // lock acquired within timeout
+}
+```
+
 Full runnable examples can be found in [`examples/`](examples/).
 
 ## Dependencies
diff --git a/include/beman/timed_lock_alg/mutex.hpp b/include/beman/timed_lock_alg/mutex.hpp
@@ -112,5 +112,154 @@ template <class Rep, class Period, detail::TimedLockable... Ls>
 [[nodiscard]] int try_lock_for(const std::chrono::duration<Rep, Period>& dur, Ls&... ls) {
     return try_lock_until(std::chrono::steady_clock::now() + dur, ls...);
 }
+
+template <detail::BasicLockable... Ms>
+class multi_lock {
+  public:
+    using mutex_type = std::tuple<Ms*...>;
+
+    // Constructors
+    multi_lock() noexcept = default;
+
+    explicit multi_lock(Ms&... ms)
+        requires(sizeof...(Ms) > 0)
+        : m_ms(std::addressof(ms)...) {
+        lock();
+    }
+
+    multi_lock(std::defer_lock_t, Ms&... ms) noexcept : m_ms(std::addressof(ms)...) {}
+
+    multi_lock(std::try_to_lock_t, Ms&... ms)
+        requires(... && detail::Lockable<Ms>)
+        : m_ms(std::addressof(ms)...) {
+        try_lock();
+    }
+
+    multi_lock(std::adopt_lock_t, Ms&... ms) noexcept : m_ms(std::addressof(ms)...), m_locked(true) {}
+
+    template <class Rep, class Period>
+        requires(... && detail::TimedLockable<Ms>)
+    multi_lock(const std::chrono::duration<Rep, Period>& dur, Ms&... ms) : m_ms(std::addressof(ms)...) {
+        try_lock_for(dur);
+    }
+
+    template <class Clock, class Duration>
+        requires(... && detail::TimedLockable<Ms>)
+    multi_lock(const std::chrono::time_point<Clock, Duration>& tp, Ms&... ms) : m_ms(std::addressof(ms)...) {
+        try_lock_until(tp);
+    }
+
+    // Destructor
+    ~multi_lock() {
+        if (m_locked)
+            unlock();
+    }
+
+    // Move operations
+    multi_lock(multi_lock&& other) noexcept
+        : m_ms(std::exchange(other.m_ms, std::tuple<Ms*...>{})), m_locked(std::exchange(other.m_locked, false)) {}
+
+    multi_lock& operator=(multi_lock&& other) noexcept {
+        multi_lock(std::move(other)).swap(*this);
+        return *this;
+    }
+
+    // Deleted copy operations
+    multi_lock(const multi_lock&)            = delete;
+    multi_lock& operator=(const multi_lock&) = delete;
+
+    // Locking operations
+  private:
+    void lock_check() {
+        if (m_locked) {
+            throw std::system_error(std::make_error_code(std::errc::resource_deadlock_would_occur));
+        }
+        if constexpr (sizeof...(Ms) != 0) {
+            if (std::get<0>(m_ms) == nullptr) {
+                throw std::system_error(std::make_error_code(std::errc::operation_not_permitted));
+            }
+        }
+    }
+
+  public:
+    void lock()
+        requires(sizeof...(Ms) == 1 || (... && detail::Lockable<Ms>))
+    {
+        lock_check();
+        if constexpr (sizeof...(Ms) == 1) {
+            std::get<sizeof...(Ms) - 1>(m_ms)->lock();
+        } else if constexpr (sizeof...(Ms) > 1) {
+            std::apply([](auto... ms) { std::lock(*ms...); }, m_ms);
+        }
+        m_locked = true;
+    }
+
+    int try_lock()
+        requires(... && detail::Lockable<Ms>)
+    {
+        lock_check();
+        int rv;
+        if constexpr (sizeof...(Ms) == 0) {
+            rv = -1;
+        } else if constexpr (sizeof...(Ms) == 1) {
+            rv = -static_cast<int>(std::get<sizeof...(Ms) - 1>(m_ms)->try_lock());
+        } else {
+            rv = std::apply([](auto... ms) { return std::try_lock(*ms...); }, m_ms);
+        }
+        m_locked = rv == -1;
+        return rv;
+    }
+
+    template <class Rep, class Period>
+        requires(... && detail::TimedLockable<Ms>)
+    int try_lock_for(const std::chrono::duration<Rep, Period>& dur) {
+        lock_check();
+        int rv   = std::apply([&](auto... ms) { return beman::timed_lock_alg::try_lock_for(dur, *ms...); }, m_ms);
+        m_locked = rv == -1;
+        return rv;
+    }
+
+    template <class Clock, class Duration>
+        requires(... && detail::TimedLockable<Ms>)
+    int try_lock_until(const std::chrono::time_point<Clock, Duration>& tp) {
+        lock_check();
+        int rv   = std::apply([&](auto... ms) { return beman::timed_lock_alg::try_lock_until(tp, *ms...); }, m_ms);
+        m_locked = rv == -1;
+        return rv;
+    }
+
+    void unlock() {
+        if (not m_locked) {
+            throw std::system_error(std::make_error_code(std::errc::operation_not_permitted));
+        }
+        auto unlocker = std::apply([](auto... ms) { return std::scoped_lock(std::adopt_lock, *ms...); }, m_ms);
+        m_locked      = false;
+    }
+
+    // Modifiers
+    void swap(multi_lock& other) noexcept {
+        std::swap(m_ms, other.m_ms);
+        std::swap(m_locked, other.m_locked);
+    }
+
+    mutex_type release() noexcept {
+        m_locked = false;
+        return std::exchange(m_ms, mutex_type{});
+    }
+
+    // Observers
+    std::tuple<Ms*...> mutex() const noexcept { return m_ms; }
+    bool               owns_lock() const noexcept { return m_locked; }
+    explicit           operator bool() const noexcept { return m_locked; }
+
+  private:
+    mutex_type m_ms;
+    bool       m_locked = false;
+};
+
+template <class... Ms>
+void swap(multi_lock<Ms...>& lhs, multi_lock<Ms...>& rhs) noexcept {
+    lhs.swap(rhs);
+}
 } // namespace beman::timed_lock_alg
 #endif
diff --git a/tests/beman/timed_lock_alg/CMakeLists.txt b/tests/beman/timed_lock_alg/CMakeLists.txt
@@ -2,12 +2,25 @@
 
 find_package(GTest REQUIRED)
 
-add_executable(beman.timed_lock_alg.tests.mutex)
-target_sources(beman.timed_lock_alg.tests.mutex PRIVATE mutex.test.cpp)
+add_executable(beman.timed_lock_alg.tests.try_lock)
+target_sources(beman.timed_lock_alg.tests.try_lock PRIVATE try_lock.test.cpp)
 target_link_libraries(
-    beman.timed_lock_alg.tests.mutex
+    beman.timed_lock_alg.tests.try_lock
     PRIVATE beman::timed_lock_alg GTest::gtest GTest::gtest_main
 )
 
 include(GoogleTest)
-gtest_discover_tests(beman.timed_lock_alg.tests.mutex)
+gtest_discover_tests(beman.timed_lock_alg.tests.try_lock)
+
+add_executable(beman.timed_lock_alg.tests.multi_lock)
+target_sources(
+    beman.timed_lock_alg.tests.multi_lock
+    PRIVATE multi_lock.test.cpp
+)
+target_link_libraries(
+    beman.timed_lock_alg.tests.multi_lock
+    PRIVATE beman::timed_lock_alg GTest::gtest GTest::gtest_main
+)
+
+include(GoogleTest)
+gtest_discover_tests(beman.timed_lock_alg.tests.multi_lock)
diff --git a/tests/beman/timed_lock_alg/mock_timed_mutex.hpp b/tests/beman/timed_lock_alg/mock_timed_mutex.hpp
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+
+#ifndef BEMAN_TIMED_LOCK_ALG_TESTS_MOCK_TIMED_MUTEX_HPP
+#define BEMAN_TIMED_LOCK_ALG_TESTS_MOCK_TIMED_MUTEX_HPP
+
+#include <atomic>
+#include <chrono>
+#include <thread>
+
+namespace beman::timed_lock_alg::test {
+
+struct MockTimedMutex {
+    std::atomic<bool> locked{false};
+    std::atomic<bool> should_fail{false};
+    std::atomic<int>  lock_count{0};
+    std::atomic<int>  unlock_count{0};
+    std::atomic<int>  try_lock_count{0};
+
+    void lock() {
+        while (should_fail)
+            std::this_thread::yield();
+        ++lock_count;
+        locked = true;
+    }
+
+    bool try_lock() {
+        ++try_lock_count;
+        if (should_fail)
+            return false;
+        ++lock_count;
+        locked = true;
+        return true;
+    }
+
+    template <class Rep, class Period>
+    bool try_lock_for(const std::chrono::duration<Rep, Period>&) {
+        return try_lock();
+    }
+
+    template <class Clock, class Duration>
+    bool try_lock_until(const std::chrono::time_point<Clock, Duration>&) {
+        return try_lock();
+    }
+
+    void unlock() {
+        ++unlock_count;
+        locked = false;
+    }
+};
+
+} // namespace beman::timed_lock_alg::test
+
+#endif // BEMAN_TIMED_LOCK_ALG_TESTS_MOCK_TIMED_MUTEX_HPP
diff --git a/tests/beman/timed_lock_alg/multi_lock.test.cpp b/tests/beman/timed_lock_alg/multi_lock.test.cpp
diff --git a/tests/beman/timed_lock_alg/try_lock.test.cpp b/tests/beman/timed_lock_alg/try_lock.test.cpp
