WIP: Check perf with dummy mutex/lock

Author: horenmar

src/CMakeLists.txt

@@ -139,6 +139,7 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/internal/catch_test_registry.hpp
   ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
   ${SOURCES_DIR}/internal/catch_textflow.hpp
+  ${SOURCES_DIR}/internal/catch_thread_support.hpp
   ${SOURCES_DIR}/internal/catch_to_string.hpp
   ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
   ${SOURCES_DIR}/internal/catch_uniform_floating_point_distribution.hpp

src/catch2/catch_all.hpp

@@ -121,6 +121,7 @@
 #include <catch2/internal/catch_test_registry.hpp>
 #include <catch2/internal/catch_test_spec_parser.hpp>
 #include <catch2/internal/catch_textflow.hpp>
+#include <catch2/internal/catch_thread_support.hpp>
 #include <catch2/internal/catch_to_string.hpp>
 #include <catch2/internal/catch_uncaught_exceptions.hpp>
 #include <catch2/internal/catch_uniform_floating_point_distribution.hpp>

src/catch2/internal/catch_run_context.cpp

@@ -312,7 +312,7 @@ namespace Catch {
         }
 
         // From here, we are touching shared state and need mutex.
-        std::lock_guard<std::mutex> lock( m_assertionMutex );
+        Detail::LockGuard lock( m_assertionMutex );
         {
             if ( Detail::g_clearMessageScopes ) {
                 m_messageScopes.clear();
@@ -334,7 +334,7 @@ namespace Catch {
 
     void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
         if (m_reportAssertionStarting) {
-            std::lock_guard<std::mutex> lock( m_assertionMutex );
+            Detail::LockGuard lock( m_assertionMutex );
             auto _ = scopedDeactivate( *m_outputRedirect );
             m_reporter->assertionStarting( info );
         }
@@ -492,7 +492,7 @@ namespace Catch {
         // m_lastResult is updated inside the assertion slow-path, so it needs to be mutexed as well
         // TODO: m_lastResult is not updated in the fast path, is there a point in support it at all?
         // TODO: also shouldn't it be a thread-local, since assertions are thread-owned until reporter?
-        std::lock_guard<std::mutex> _( m_assertionMutex );
+        Detail::LockGuard _( m_assertionMutex );
         return &(*m_lastResult);
     }
 
@@ -509,7 +509,7 @@ namespace Catch {
             // the fake assertion and stuff.
             // TODO: Should we unlock? Trying to let other threads run while fatal error
             //       is happening is... ill-advised.
-            std::lock_guard<std::mutex> lock( m_assertionMutex );
+            Detail::LockGuard lock( m_assertionMutex );
             // TODO: scoped deactivate here? Just give up and do best effort?
             //       the deactivation can break things further, OTOH so can the
             //       capture
@@ -530,7 +530,7 @@ namespace Catch {
 
 
         // TODO: Should we keep granular locks here, or take a single lock at the start?
-        std::lock_guard<std::mutex> lock( m_assertionMutex );
+        Detail::LockGuard lock( m_assertionMutex );
         // Best effort cleanup for sections that have not been destructed yet
         // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
         while (!m_activeSections.empty()) {

src/catch2/internal/catch_run_context.hpp

@@ -20,9 +20,9 @@
 #include <catch2/catch_assertion_result.hpp>
 #include <catch2/internal/catch_optional.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_thread_support.hpp>
 
 #include <atomic>
-#include <mutex>
 #include <string>
 
 namespace Catch {
@@ -153,7 +153,7 @@ namespace Catch {
 
         void handleUnfinishedSections();
         // TODO: Make this a recursive mutex if we use a single big mutex in the fatal error handler
-        mutable std::mutex m_assertionMutex;
+        mutable Detail::Mutex m_assertionMutex;
         TestRunInfo m_runInfo;
         TestCaseHandle const* m_activeTestCase = nullptr;
         ITracker* m_testCaseTracker = nullptr;

src/catch2/meson.build

@@ -147,6 +147,7 @@ internal_headers = [
   'internal/catch_test_registry.hpp',
   'internal/catch_test_spec_parser.hpp',
   'internal/catch_textflow.hpp',
+  'internal/catch_thread_support.hpp',
   'internal/catch_to_string.hpp',
   'internal/catch_uncaught_exceptions.hpp',
   'internal/catch_uniform_floating_point_distribution.hpp',

tests/SelfTest/UsageTests/Misc.tests.cpp

@@ -563,19 +563,19 @@ TEST_CASE("Validate SEH behavior - no crash for stack unwinding", "[approvals][!
 
 #endif // _MSC_VER
 
-#include <thread>
-
-TEST_CASE( "threads" ) {
-    std::vector<std::thread> threads;
-    for ( size_t t = 0; t < 16; ++t) {
-        threads.emplace_back( []() {
-            for (size_t i = 0; i < 10'000; ++i) {
-                CHECK( false );
-            }
-        } );
-    }
-
-    for (auto& t : threads) {
-        t.join();
-    }
-}
+//#include <thread>
+//
+//TEST_CASE( "threads" ) {
+//    std::vector<std::thread> threads;
+//    for ( size_t t = 0; t < 16; ++t) {
+//        threads.emplace_back( []() {
+//            for (size_t i = 0; i < 10'000; ++i) {
+//                CHECK( false );
+//            }
+//        } );
+//    }
+//
+//    for (auto& t : threads) {
+//        t.join();
+//    }
+//}