test: add tests for py::scoped_critical_section

Author: XuehaiPan

tests/CMakeLists.txt

@@ -166,6 +166,7 @@ set(PYBIND11_TEST_FILES
     test_potentially_slicing_weak_ptr
     test_python_multiple_inheritance
     test_pytypes
+    test_scoped_critical_section
     test_sequences_and_iterators
     test_smart_ptr
     test_stl

tests/test_scoped_critical_section.cpp

@@ -0,0 +1,132 @@
+#include <pybind11/critical_section.h>
+
+#include "catch.hpp"
+#include "pybind11_tests.h"
+
+#include <atomic>
+#include <thread>
+
+#ifdef PYBIND11_CPP20
+#    include <barrier>
+
+// Referenced test implementation: https://github.com/PyO3/pyo3/blob/v0.25.0/src/sync.rs#L874
+class BoolWrapper {
+public:
+    explicit BoolWrapper(bool value) : value_{value} {}
+    bool get() const { return value_.load(std::memory_order_acquire); }
+    void set(bool value) { value_.store(value, std::memory_order_release); }
+
+private:
+    std::atomic<bool> value_;
+};
+
+void test_scoped_critical_section(py::class_<BoolWrapper> &cls) {
+    auto barrier = std::barrier(2);
+    auto bool_wrapper = cls(false);
+
+    std::thread t1([&]() {
+        py::scoped_critical_section lock{bool_wrapper};
+        barrier.arrive_and_wait();
+        auto bw = bool_wrapper.cast<std::shared_ptr<BoolWrapper>>();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        bw->set(true);
+    });
+
+    std::thread t2([&]() {
+        barrier.arrive_and_wait();
+        py::scoped_critical_section lock{bool_wrapper};
+        auto bw = bool_wrapper.cast<std::shared_ptr<BoolWrapper>>();
+        REQUIRE(bw->get() == true);
+    });
+
+    t1.join();
+    t2.join();
+}
+
+void test_scoped_critical_section2(py::class_<BoolWrapper> &cls) {
+    auto barrier = std::barrier(3);
+    auto bool_wrapper1 = cls(false);
+    auto bool_wrapper2 = cls(false);
+
+    std::thread t1([&]() {
+        py::scoped_critical_section lock{bool_wrapper1, bool_wrapper2};
+        barrier.arrive_and_wait();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        auto bw1 = bool_wrapper1.cast<std::shared_ptr<BoolWrapper>>();
+        auto bw2 = bool_wrapper2.cast<std::shared_ptr<BoolWrapper>>();
+        bw1->set(true);
+        bw2->set(true);
+    });
+
+    std::thread t2([&]() {
+        barrier.arrive_and_wait();
+        py::scoped_critical_section lock{bool_wrapper1};
+        auto bw1 = bool_wrapper1.cast<std::shared_ptr<BoolWrapper>>();
+        REQUIRE(bw1->get() == true);
+    });
+
+    std::thread t3([&]() {
+        barrier.arrive_and_wait();
+        py::scoped_critical_section lock{bool_wrapper2};
+        auto bw2 = bool_wrapper2.cast<std::shared_ptr<BoolWrapper>>();
+        REQUIRE(bw2->get() == true);
+    });
+
+    t1.join();
+    t2.join();
+    t3.join();
+}
+
+void test_scoped_critical_section2_same_object_no_deadlock(py::class_<BoolWrapper> &cls) {
+    auto barrier = std::barrier(2);
+    auto bool_wrapper = cls(false);
+
+    std::thread t1([&]() {
+        py::scoped_critical_section lock{bool_wrapper, bool_wrapper};
+        barrier.arrive_and_wait();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        auto bw = bool_wrapper.cast<std::shared_ptr<BoolWrapper>>();
+        bw->set(true);
+    });
+
+    std::thread t2([&]() {
+        barrier.arrive_and_wait();
+        py::scoped_critical_section lock{bool_wrapper};
+        auto bw = bool_wrapper.cast<std::shared_ptr<BoolWrapper>>();
+        REQUIRE(bw->get() == true);
+    });
+
+    t1.join();
+    t2.join();
+}
+#endif
+
+TEST_SUBMODULE(scoped_critical_section, m) {
+    m.attr("defined_THREAD_SANITIZER") =
+#if defined(THREAD_SANITIZER)
+        true;
+#else
+        false;
+#endif
+    m.attr("has_barrier") =
+#if defined(PYBIND11_CPP20)
+        true;
+#else
+        false;
+#endif
+
+#ifdef PYBIND11_CPP20
+    auto BoolWrapperClass = py::class_<BoolWrapper>(m, "BoolWrapper")
+                                .def(py::init<bool>())
+                                .def("get", &BoolWrapper::get)
+                                .def("set", &BoolWrapper::set);
+
+    m.def("test_scoped_critical_section",
+          [&]() -> void { test_scoped_critical_section(BoolWrapperClass); });
+    m.def("test_scoped_critical_section2",
+          [&]() -> void { test_scoped_critical_section2(BoolWrapperClass); });
+    m.def("test_scoped_critical_section2_same_object_no_deadlock", [&]() -> void {
+        test_scoped_critical_section2_same_object_no_deadlock(BoolWrapperClass);
+    });
+#endif
+}

tests/test_scoped_critical_section.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import pytest
+
+from pybind11_tests import scoped_critical_section as m
+
+
+@pytest.mark.skipif(not m.has_barrier, reason="no <barrier>")
+def test_scoped_critical_section() -> None:
+    for _ in range(64):
+        m.test_scoped_critical_section()
+
+
+@pytest.mark.skipif(not m.has_barrier, reason="no <barrier>")
+def test_scoped_critical_section2() -> None:
+    for _ in range(64):
+        assert m.test_scoped_critical_section2()
+
+
+@pytest.mark.skipif(not m.has_barrier, reason="no <barrier>")
+def test_scoped_critical_section2_same_object_no_deadlock() -> None:
+    for _ in range(64):
+        m.test_scoped_critical_section2_same_object_no_deadlock()