[libcxxabi][SystemZ][z/OS] Added HybridGuard to cxa_guard

[DanielMcIntosh-IBM]

Summary

As described in D110349, on z/OS applications don't know at compile
time if threading support is enabled, so cxa_guard has to check that
at runtime, and adjust it's behaviour accordingly.

However, rather than checking if threading support is enabled, we can
instead check if there are potentially other threads running, and get
a little extra performance out of single-threaded applications.

This PR is the motivating factor for overhauling cxa_guard in D108343

Depends on D115369, D110349

[DanielMcIntosh-IBM]

Ping

[DanielMcIntosh-IBM]

Update function names as a result of changes to D110349

[DanielMcIntosh-IBM]

Update because of changes to dependent revisions

libcxxabi/src/cxa_guard_impl.h

public:
   bool compare_exchange(IntType* expected, IntType desired, MemoryOrder ord_success, MemoryOrder ord_failure) {
     return std::__libcpp_atomic_compare_exchange(b_, expected, desired, ord_success, ord_failure);
   }
 
 private:
   IntType* b_;
 };
 
+#ifdef _LIBCXXABI_HAS_NO_THREADS
+static inline bool IsThreaded() { return false; }
+#else
+static inline bool IsThreaded() { return std::__libcpp_might_have_multiple_threads(); }
+#endif
+
 //===----------------------------------------------------------------------===//
 //                       PlatformGetThreadID
 //===----------------------------------------------------------------------===//
 
 #if defined(__APPLE__) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 uint32_t PlatformThreadID() {
   static_assert(sizeof(mach_port_t) == sizeof(uint32_t), "");
   return static_cast<uint32_t>(pthread_mach_thread_np(std::__libcpp_thread_get_current_id()));
static int expected_value_for_futex(uint8_t b) {
     std::memcpy(reinterpret_cast<char*>(&dest_val) + 1, &b, 1);
     return dest_val;
   }
 
   static_assert(Wait != nullptr && Wake != nullptr, "");
 };
 
 //===----------------------------------------------------------------------===//
+//                         Hybrid Implementation
+//===----------------------------------------------------------------------===//
+
+/// InitByteHybrid - At runtime determines whether we're in a single-threaded
+/// or multi-threaded environment. Then manages reads and writes to the init
+/// byte by delegating to either InitByteNoThreads or InitByteGlobalMutex.
+template <class Mutex, class CondVar, Mutex& global_mutex, CondVar& global_cond,
+          uint32_t (*GetThreadID)() = PlatformThreadID, bool (*ImpSelector)() = IsThreaded>
+struct InitByteHybrid {
+  using InitByteGlobalMutexT = InitByteGlobalMutex<Mutex, CondVar, global_mutex, global_cond, GetThreadID>;
+
+private:
+  InitByteNoThreads init_byte_no_threads;
+  InitByteGlobalMutexT init_byte_global_mutex;
+
+public:
+  InitByteHybrid() = delete;
+  InitByteHybrid(InitByteHybrid const&) = delete;
+  InitByteHybrid& operator=(InitByteHybrid const&) = delete;
+
+  explicit InitByteHybrid(uint8_t* _init_byte_address, uint32_t* _thread_id_address)
+      : init_byte_no_threads(_init_byte_address, _thread_id_address),
+        init_byte_global_mutex(_init_byte_address, _thread_id_address) {}
+
+  /// The init_byte portion of cxa_guard_acquire. Returns true if
+  /// initialization has already been completed.
+  bool acquire() {
+    if (ImpSelector())
+      return init_byte_global_mutex.acquire();
+    else
+      return init_byte_no_threads.acquire();
+  }
+
+  /// The init_byte portion of cxa_guard_release.
+  void release() {
+    if (ImpSelector())
+      return init_byte_global_mutex.release();
+    else
+      return init_byte_no_threads.release();
+  }
+
+  /// The init_byte portion of cxa_guard_abort.
+  void abort() {
+    if (ImpSelector())
+      return init_byte_global_mutex.abort();
+    else
+      return init_byte_no_threads.abort();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 //                          GuardObject
 //===----------------------------------------------------------------------===//
 
 enum class AcquireResult {
   INIT_IS_DONE,
   INIT_IS_PENDING,
 };
 constexpr AcquireResult INIT_IS_DONE = AcquireResult::INIT_IS_DONE;

 using GlobalMutexGuard = GuardObject<InitByteGlobalMutex<Mutex, CondVar, global_mutex, global_cond, GetThreadID>>;
 
 /// FutexGuard - Manages initialization using atomics and the futex syscall for
 /// waiting and waking.
 template <void (*Wait)(int*, int) = PlatformFutexWait, void (*Wake)(int*) = PlatformFutexWake,
           uint32_t (*GetThreadIDArg)() = PlatformThreadID>
 using FutexGuard = GuardObject<InitByteFutex<Wait, Wake, GetThreadIDArg>>;
 
+/// HybridGuard - Manages initialization using a hybrid of InitByteNoThreads
+/// and InitByteGlobalMutex
+template <class Mutex, class CondVar, Mutex& global_mutex, CondVar& global_cond,
+          uint32_t (*GetThreadID)() = PlatformThreadID, bool (*ImpSelector)() = IsThreaded>
+using HybridGuard = GuardObject<InitByteHybrid<Mutex, CondVar, global_mutex, global_cond, GetThreadID, ImpSelector>>;
+
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
 template <class T>
 struct GlobalStatic {
   static T instance;
 };
 template <class T>
 _LIBCPP_SAFE_STATIC T GlobalStatic<T>::instance = {};
 
-enum class Implementation { NoThreads, GlobalMutex, Futex };
+enum class Implementation { NoThreads, GlobalMutex, Futex, Hybrid };
 
 template <Implementation Impl>
 struct SelectImplementation;
 
 template <>
 struct SelectImplementation<Implementation::NoThreads> {
   using type = NoThreadsGuard;
 };
 
 template <>
 struct SelectImplementation<Implementation::GlobalMutex> {
   using type = GlobalMutexGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
                                 GlobalStatic<LibcppCondVar>::instance, PlatformThreadID>;
 };
 
 template <>
 struct SelectImplementation<Implementation::Futex> {
   using type = FutexGuard<PlatformFutexWait, PlatformFutexWake, PlatformThreadID>;
 };
 
+template <>
+struct SelectImplementation<Implementation::Hybrid> {
+  using type = HybridGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
+                           GlobalStatic<LibcppCondVar>::instance, PlatformThreadID>;
+};
+
 // TODO(EricWF): We should prefer the futex implementation when available. But
 // it should be done in a separate step from adding the implementation.
 constexpr Implementation CurrentImplementation =
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     Implementation::NoThreads;
+#elif defined(__MVS__)
+    Implementation::Hybrid;
 #elif defined(_LIBCXXABI_USE_FUTEX)
     Implementation::Futex;
 #else
     Implementation::GlobalMutex;
 #endif
 
 static_assert(CurrentImplementation != Implementation::Futex || PlatformSupportsFutex(),
               "Futex selected but not supported");

libcxxabi/test/guard_test_basic.pass.cpp

struct NopCondVar {
   bool wait(NopMutex&) { return false; }
 };
 NopCondVar global_nop_cond = {};
 
 void NopFutexWait(int*, int) { assert(false); }
 void NopFutexWake(int*) { assert(false); }
 uint32_t MockGetThreadID() { return 0; }
 
+bool ImpSelectorFalse() { return false; }
+bool ImpSelectorTrue() { return true; }
+
 int main(int, char**) {
   {
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     static_assert(CurrentImplementation == Implementation::NoThreads, "");
     static_assert(std::is_same<SelectedImplementation, NoThreadsGuard>::value, "");
+#elif defined(__MVS__)
+    static_assert(CurrentImplementation == Implementation::Hybrid, "");
+    static_assert(std::is_same<SelectedImplementation,
+                               HybridGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
+                                           GlobalStatic<LibcppCondVar>::instance>>::value,
+                  "");
 #else
     static_assert(CurrentImplementation == Implementation::GlobalMutex, "");
     static_assert(std::is_same<SelectedImplementation,
                                GlobalMutexGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
                                                 GlobalStatic<LibcppCondVar>::instance>>::value,
                   "");
 #endif
   }
#endif
     Tests<uint32_t, MutexImpl>::test();
     Tests<uint64_t, MutexImpl>::test();
   }
   {
     using FutexImpl = FutexGuard<&NopFutexWait, &NopFutexWake, &MockGetThreadID>;
     Tests<uint32_t, FutexImpl>::test();
     Tests<uint64_t, FutexImpl>::test();
   }
+  {
+    using HybridImplNothreads =
+        HybridGuard<NopMutex, NopCondVar, global_nop_mutex, global_nop_cond, MockGetThreadID, ImpSelectorFalse>;
+    using HybridImplThreaded =
+        HybridGuard<NopMutex, NopCondVar, global_nop_mutex, global_nop_cond, MockGetThreadID, ImpSelectorTrue>;
+    Tests<uint32_t, HybridImplNothreads>::test();
+    Tests<uint64_t, HybridImplNothreads>::test();
+    Tests<uint32_t, HybridImplThreaded>::test();
+    Tests<uint64_t, HybridImplThreaded>::test();
+  }
 
   return 0;
 }

libcxxabi/test/guard_threaded_test.pass.cpp

for (auto test_func : TestList) {
         }
       });
       test_threads.JoinAll();
     }
   }
 
 void test_all_impls() {
   using MutexImpl = SelectImplementation<Implementation::GlobalMutex>::type;
+  using HybridImpl = SelectImplementation<Implementation::Hybrid>::type;
 
   // Attempt to test the Futex based implementation if it's supported on the
   // target platform.
   using RealFutexImpl = SelectImplementation<Implementation::Futex>::type;
   using FutexImpl = typename std::conditional<
       PlatformSupportsFutex(),
       RealFutexImpl,
       MutexImpl
   >::type;
 
   test_impl<MutexImpl>();
+  test_impl<HybridImpl>();
   if (PlatformSupportsFutex())
     test_impl<FutexImpl>();
 }
 
 // A dummy
 template <bool Dummy = true>
 void test_futex_syscall() {
   if (!PlatformSupportsFutex())