[K/N][New MM] Check if asserts are enabled in thread state asserts

kotlin-native/runtime/src/main/cpp/Memory.h

@@ -414,11 +414,17 @@ ALWAYS_INLINE void AssertThreadState(MemoryState* thread, std::initializer_list<
 
 // Asserts that the current thread is in the the given state.
 ALWAYS_INLINE inline void AssertThreadState(ThreadState expected) noexcept {
-    AssertThreadState(mm::GetMemoryState(), expected);
+    // Avoid redundant TLS access in GetMemoryState if runtime asserts are disabled.
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        AssertThreadState(mm::GetMemoryState(), expected);
+    }
 }
 
 ALWAYS_INLINE inline void AssertThreadState(std::initializer_list<ThreadState> expected) noexcept {
-    AssertThreadState(mm::GetMemoryState(), expected);
+    // Avoid redundant TLS access in GetMemoryState if runtime asserts are disabled.
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        AssertThreadState(mm::GetMemoryState(), expected);
+    }
 }
 
 // Scopely sets the given thread state for the given thread.

kotlin-native/runtime/src/mm/cpp/ThreadState.cpp

@@ -33,11 +33,17 @@ ALWAYS_INLINE ThreadState kotlin::SwitchThreadState(MemoryState* thread, ThreadS
 }
 
 ALWAYS_INLINE void kotlin::AssertThreadState(MemoryState* thread, ThreadState expected) noexcept {
-    AssertThreadState(thread->GetThreadData(), expected);
+    // Avoid redundant read in GetThreadData if runtime asserts are disabled.
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        AssertThreadState(thread->GetThreadData(), expected);
+    }
 }
 
 ALWAYS_INLINE void kotlin::AssertThreadState(MemoryState* thread, std::initializer_list<ThreadState> expected) noexcept {
-    AssertThreadState(thread->GetThreadData(), expected);
+    // Avoid redundant read in GetThreadData if runtime asserts are disabled.
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        AssertThreadState(thread->GetThreadData(), expected);
+    }
 }
 
 ThreadState kotlin::GetThreadState(MemoryState* thread) noexcept {

kotlin-native/runtime/src/mm/cpp/ThreadState.hpp

@@ -38,17 +38,28 @@ ALWAYS_INLINE inline ThreadState SwitchThreadState(mm::ThreadData* threadData, T
 
 // Asserts that the given thread is in the given state.
 ALWAYS_INLINE inline void AssertThreadState(mm::ThreadData* threadData, ThreadState expected) noexcept {
-    auto actual = threadData->state();
+    // The read of the thread state is atomic, thus the compiler cannot eliminate it
-    RuntimeAssert(actual == expected,
+    // even if its result is unused due to disabled runtime asserts.
-                  "Unexpected thread state. Expected: %s. Actual: %s.",
+    // So we explicitly avoid the read if asserts are disabled.
-                  ThreadStateName(expected), ThreadStateName(actual));
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        auto actual = threadData->state();
+        RuntimeAssert(
+                actual == expected, "Unexpected thread state. Expected: %s. Actual: %s.", ThreadStateName(expected),
+                ThreadStateName(actual));
+    }
 }
 
 ALWAYS_INLINE inline void AssertThreadState(mm::ThreadData* threadData, std::initializer_list<ThreadState> expected) noexcept {
-    auto actual = threadData->state();
+    // The read of the thread state is atomic, thus the compiler cannot eliminate it
-    RuntimeAssert(std::any_of(expected.begin(), expected.end(), [actual](ThreadState expected) { return expected == actual; }),
+    // even if its result is unused due to disabled runtime asserts.
-                  "Unexpected thread state. Expected one of: %s. Actual: %s",
+    // So we explicitly avoid the read if asserts are disabled.
-                  internal::statesToString(expected).c_str(), ThreadStateName(actual));
+    if (compiler::runtimeAssertsMode() != compiler::RuntimeAssertsMode::kIgnore) {
+        auto actual = threadData->state();
+        RuntimeAssert(
+                std::any_of(expected.begin(), expected.end(), [actual](ThreadState expected) { return expected == actual; }),
+                "Unexpected thread state. Expected one of: %s. Actual: %s", internal::statesToString(expected).c_str(),
+                ThreadStateName(actual));
+    }
 }
 
 } // namespace kotlin