mutex.cpp, cond.cpp: Use static dispatch

stl/src/cond.cpp

@@ -15,9 +15,9 @@ struct _Cnd_internal_imp_t { // condition variable implementation for ConcRT
     typename std::_Aligned_storage<Concurrency::details::stl_condition_variable_max_size,
         Concurrency::details::stl_condition_variable_max_alignment>::type cv;
 
-    [[nodiscard]] Concurrency::details::stl_condition_variable_interface* _get_cv() noexcept {
+    [[nodiscard]] Concurrency::details::stl_condition_variable_win7* _get_cv() noexcept {
         // get pointer to implementation
-        return reinterpret_cast<Concurrency::details::stl_condition_variable_interface*>(&cv);
+        return reinterpret_cast<Concurrency::details::stl_condition_variable_win7*>(&cv);
     }
 };
 
@@ -53,7 +53,7 @@ void _Cnd_destroy(const _Cnd_t cond) { // clean up
 }
 
 int _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) { // wait until signaled
-    const auto cs = static_cast<Concurrency::details::stl_critical_section_interface*>(_Mtx_getconcrtcs(mtx));
+    const auto cs = static_cast<Concurrency::details::stl_critical_section_win7*>(_Mtx_getconcrtcs(mtx));
     _Mtx_clear_owner(mtx);
     cond->_get_cv()->wait(cs);
     _Mtx_reset_owner(mtx);
@@ -63,7 +63,7 @@ int _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) { // wait until signaled
 // wait until signaled or timeout
 int _Cnd_timedwait(const _Cnd_t cond, const _Mtx_t mtx, const _timespec64* const target) {
     int res       = _Thrd_success;
-    const auto cs = static_cast<Concurrency::details::stl_critical_section_interface*>(_Mtx_getconcrtcs(mtx));
+    const auto cs = static_cast<Concurrency::details::stl_critical_section_win7*>(_Mtx_getconcrtcs(mtx));
     if (target == nullptr) { // no target time specified, wait on mutex
         _Mtx_clear_owner(mtx);
         cond->_get_cv()->wait(cs);

stl/src/mutex.cpp

@@ -43,8 +43,8 @@ struct _Mtx_internal_imp_t { // ConcRT mutex
         Concurrency::details::stl_critical_section_max_alignment>::type cs;
     long thread_id;
     int count;
-    Concurrency::details::stl_critical_section_interface* _get_cs() { // get pointer to implementation
-        return reinterpret_cast<Concurrency::details::stl_critical_section_interface*>(&cs);
+    [[nodiscard]] Concurrency::details::stl_critical_section_win7* _get_cs() { // get pointer to implementation
+        return reinterpret_cast<Concurrency::details::stl_critical_section_win7*>(&cs);
     }
 };
 

stl/src/primitives.hpp

@@ -10,48 +10,30 @@
 
 namespace Concurrency {
     namespace details {
-        class __declspec(novtable) stl_critical_section_interface {
-        public:
-            virtual void lock()                     = 0;
-            virtual bool try_lock()                 = 0;
-            virtual bool try_lock_for(unsigned int) = 0;
-            virtual void unlock()                   = 0;
-            virtual void destroy()                  = 0;
-        };
-
-        class __declspec(novtable) stl_condition_variable_interface {
-        public:
-            virtual void wait(stl_critical_section_interface*)                   = 0;
-            virtual bool wait_for(stl_critical_section_interface*, unsigned int) = 0;
-            virtual void notify_one()                                            = 0;
-            virtual void notify_all()                                            = 0;
-            virtual void destroy()                                               = 0;
-        };
-
-        class stl_critical_section_win7 final : public stl_critical_section_interface {
+        class stl_critical_section_win7 {
         public:
             stl_critical_section_win7() = default;
 
             ~stl_critical_section_win7()                                           = delete;
             stl_critical_section_win7(const stl_critical_section_win7&)            = delete;
             stl_critical_section_win7& operator=(const stl_critical_section_win7&) = delete;
 
-            void destroy() override {}
+            void destroy() {}
 
-            void lock() override {
+            void lock() {
                 AcquireSRWLockExclusive(&m_srw_lock);
             }
 
-            bool try_lock() override {
+            bool try_lock() {
                 return TryAcquireSRWLockExclusive(&m_srw_lock) != 0;
             }
 
-            bool try_lock_for(unsigned int) override {
+            bool try_lock_for(unsigned int) {
                 // STL will call try_lock_for once again if this call will not succeed
                 return stl_critical_section_win7::try_lock();
             }
 
-            void unlock() override {
+            void unlock() {
                 _Analysis_assume_lock_held_(m_srw_lock);
                 ReleaseSRWLockExclusive(&m_srw_lock);
             }
@@ -61,50 +43,48 @@ namespace Concurrency {
             }
 
         private:
+            void* unused       = nullptr; // TRANSITON, ABI: was the vptr
             SRWLOCK m_srw_lock = SRWLOCK_INIT;
         };
 
-        class stl_condition_variable_win7 final : public stl_condition_variable_interface {
+        class stl_condition_variable_win7 {
         public:
-            stl_condition_variable_win7() {
-                InitializeConditionVariable(&m_condition_variable);
-            }
+            stl_condition_variable_win7() = default;
 
             ~stl_condition_variable_win7()                                             = delete;
             stl_condition_variable_win7(const stl_condition_variable_win7&)            = delete;
             stl_condition_variable_win7& operator=(const stl_condition_variable_win7&) = delete;
 
-            void destroy() override {}
+            void destroy() {}
 
-            void wait(stl_critical_section_interface* lock) override {
+            void wait(stl_critical_section_win7* lock) {
                 if (!stl_condition_variable_win7::wait_for(lock, INFINITE)) {
                     std::terminate();
                 }
             }
 
-            bool wait_for(stl_critical_section_interface* lock, unsigned int timeout) override {
-                return SleepConditionVariableSRW(&m_condition_variable,
-                           static_cast<stl_critical_section_win7*>(lock)->native_handle(), timeout, 0)
-                    != 0;
+            bool wait_for(stl_critical_section_win7* lock, unsigned int timeout) {
+                return SleepConditionVariableSRW(&m_condition_variable, lock->native_handle(), timeout, 0) != 0;
             }
 
-            void notify_one() override {
+            void notify_one() {
                 WakeConditionVariable(&m_condition_variable);
             }
 
-            void notify_all() override {
+            void notify_all() {
                 WakeAllConditionVariable(&m_condition_variable);
             }
 
         private:
-            CONDITION_VARIABLE m_condition_variable;
+            void* unused                            = nullptr; // TRANSITON, ABI: was the vptr
+            CONDITION_VARIABLE m_condition_variable = CONDITION_VARIABLE_INIT;
         };
 
-        inline void create_stl_critical_section(stl_critical_section_interface* p) {
+        inline void create_stl_critical_section(stl_critical_section_win7* p) {
             new (p) stl_critical_section_win7;
         }
 
-        inline void create_stl_condition_variable(stl_condition_variable_interface* p) {
+        inline void create_stl_condition_variable(stl_condition_variable_win7* p) {
             new (p) stl_condition_variable_win7;
         }