Function test_scoped_critical_section2

tests/test_scoped_critical_section.cpp:102–178

}

void test_scoped_critical_section2(const py::handle &cls) {
    auto barrier = std::barrier(3);
    auto bool_wrapper1 = cls(false);
    auto bool_wrapper2 = cls(false);
    std::pair<bool, bool> output{false, false};

    {
        // Release the GIL to allow run threads in parallel.
        py::gil_scoped_release gil_release{};

        std::thread t1([&]() {
            // Use gil_scoped_acquire to ensure we have a valid Python thread state
            // before entering the critical section. Otherwise, the critical section
            // will cause a segmentation fault.
            py::gil_scoped_acquire ensure_tstate{};
            // Enter the critical section with two different objects.
            // This will ensure that the critical section is locked for both objects.
            py::scoped_critical_section lock{bool_wrapper1, bool_wrapper2};
            // At this point, objects are locked by this thread via the scoped_critical_section.
            // This barrier will ensure that other threads wait until this thread has released
            // the critical section before proceeding.
            barrier.arrive_and_wait();
            // Sleep for a short time to simulate some work in the critical section.
            // This sleep is necessary to test the locking mechanism properly.
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            auto *bw1 = bool_wrapper1.cast<BoolWrapper *>();
            auto *bw2 = bool_wrapper2.cast<BoolWrapper *>();
            bw1->set(true);
            bw2->set(true);
        });

        std::thread t2([&]() {
            // This thread will wait until the first thread has entered the critical section due to
            // the barrier.
            barrier.arrive_and_wait();
            {
                // Use gil_scoped_acquire to ensure we have a valid Python thread state
                // before entering the critical section. Otherwise, the critical section
                // will cause a segmentation fault.
                py::gil_scoped_acquire ensure_tstate{};
                // Enter the critical section with the same object as the first thread.
                py::scoped_critical_section lock{bool_wrapper1};
                // At this point, the critical section is released by the first thread, the value
                // is set to true.
                auto *bw1 = bool_wrapper1.cast<BoolWrapper *>();
                output.first = bw1->get();
            }
        });

        std::thread t3([&]() {
            // This thread will wait until the first thread has entered the critical section due to
            // the barrier.
            barrier.arrive_and_wait();
            {
                // Use gil_scoped_acquire to ensure we have a valid Python thread state
                // before entering the critical section. Otherwise, the critical section
                // will cause a segmentation fault.
                py::gil_scoped_acquire ensure_tstate{};