Get rid of old Kotlin/Native memory model

Fixes #3375

Author: qwwdfsad

kotlinx-coroutines-core/build.gradle

@@ -56,6 +56,7 @@ void defineSourceSet(newName, dependsOn, includedInPred) {
 }
 
 static boolean isNativeDarwin(String name) { return ["ios", "macos", "tvos", "watchos"].any { name.startsWith(it) } }
+
 static boolean isNativeOther(String name) { return ["linux", "mingw"].any { name.startsWith(it) } }
 
 defineSourceSet("concurrent", ["common"]) { it in ["jvm", "native"] }
@@ -77,40 +78,18 @@ kotlin {
     }
 
     /*
-     * Configure four test runs:
-     * 1) Old memory model, Main thread
-     * 2) New memory model, Main thread
-     * 3) Old memory model, BG thread
-     * 4) New memory model, BG thread (required for Dispatchers.Main tests on Darwin)
+     * Configure two test runs:
+     * 1) New memory model, Main thread
+     * 2) New memory model, BG thread (required for Dispatchers.Main tests on Darwin)
      *
      * All new MM targets are build with optimize = true to have stress tests properly run.
      */
     targets.withType(org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTargetWithTests.class).configureEach {
-        binaries {
-            // Test for memory leaks using a special entry point that does not exit but returns from main
-            binaries.getTest("DEBUG").freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
-        }
-
-        binaries.test("newMM", [DEBUG]) {
-            def thisTest = it
-            freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
-            optimized = true
-            binaryOptions["memoryModel"] = "experimental"
-            testRuns.create("newMM") {
-                setExecutionSourceFrom(thisTest)
-                // A hack to get different suffixes in the aggregated report.
-                executionTask.configure { targetName = "$targetName new MM" }
-            }
-        }
-
-        binaries.test("worker",  [DEBUG]) {
-            def thisTest = it
-            freeCompilerArgs += ["-e", "kotlinx.coroutines.mainBackground"]
-            testRuns.create("worker") {
-                setExecutionSourceFrom(thisTest)
-                executionTask.configure { targetName = "$targetName worker" }
-            }
-        }
+        def defaultTests = binaries.getTest("DEBUG")
+        // Test for memory leaks using a special entry point that does not exit but returns from main
+        defaultTests.freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
+        defaultTests.optimized = true
+        defaultTests.binaryOptions["memoryModel"] = "experimental"
 
         binaries.test("workerWithNewMM", [DEBUG]) {
             def thisTest = it
@@ -150,11 +129,11 @@ def configureNativeSourceSetPreset(name, preset) {
     def implementationConfiguration = configurations[hostMainCompilation.defaultSourceSet.implementationMetadataConfigurationName]
     // Now find the libraries: Finds platform libs & stdlib, but platform declarations are still not resolved due to IDE bugs
     def hostNativePlatformLibs = files(
-        provider {
-            implementationConfiguration.findAll {
-                it.path.endsWith(".klib") || it.absolutePath.contains("klib${File.separator}platform") || it.absolutePath.contains("stdlib")
+            provider {
+                implementationConfiguration.findAll {
+                    it.path.endsWith(".klib") || it.absolutePath.contains("klib${File.separator}platform") || it.absolutePath.contains("stdlib")
+                }
             }
-        }
     )
     // Add all those dependencies
     for (suffix in sourceSetSuffixes) {

kotlinx-coroutines-core/concurrent/test/AbstractDispatcherConcurrencyTest.kt

@@ -12,7 +12,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
    public abstract val dispatcher: CoroutineDispatcher
 
     @Test
-    fun testLaunchAndJoin() = runMtTest {
+    fun testLaunchAndJoin() = runTest {
         expect(1)
         var capturedMutableState = 0
         val job = GlobalScope.launch(dispatcher) {
@@ -25,7 +25,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
     }
 
     @Test
-    fun testDispatcherHasOwnThreads() = runMtTest {
+    fun testDispatcherHasOwnThreads() = runTest {
         val channel = Channel<Int>()
         GlobalScope.launch(dispatcher) {
             channel.send(42)
@@ -41,7 +41,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
     }
 
     @Test
-    fun testDelayInDispatcher() = runMtTest {
+    fun testDelayInDispatcher() = runTest {
         expect(1)
         val job = GlobalScope.launch(dispatcher) {
             expect(2)

kotlinx-coroutines-core/concurrent/test/ConcurrentExceptionsStressTest.kt

@@ -22,7 +22,7 @@ class ConcurrentExceptionsStressTest : TestBase() {
     }
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         workers = Array(nWorkers) { index ->
             newSingleThreadContext("JobExceptionsStressTest-$index")
         }

kotlinx-coroutines-core/concurrent/test/JobStructuredJoinStressTest.kt

@@ -16,12 +16,12 @@ class JobStructuredJoinStressTest : TestBase() {
     private val nRepeats = 10_000 * stressTestMultiplier
 
     @Test
-    fun testStressRegularJoin() = runMtTest {
+    fun testStressRegularJoin() = runTest {
         stress(Job::join)
     }
 
     @Test
-    fun testStressSuspendCancellable() = runMtTest {
+    fun testStressSuspendCancellable() = runTest {
         stress { job ->
             suspendCancellableCoroutine { cont ->
                 job.invokeOnCompletion { cont.resume(Unit) }
@@ -30,7 +30,7 @@ class JobStructuredJoinStressTest : TestBase() {
     }
 
     @Test
-    fun testStressSuspendCancellableReusable() = runMtTest {
+    fun testStressSuspendCancellableReusable() = runTest {
         stress { job ->
             suspendCancellableCoroutineReusable { cont ->
                 job.invokeOnCompletion { cont.resume(Unit) }

kotlinx-coroutines-core/concurrent/test/LimitedParallelismConcurrentTest.kt

@@ -23,7 +23,7 @@ class LimitedParallelismConcurrentTest : TestBase() {
     }
 
     @Test
-    fun testLimitedExecutor() = runMtTest {
+    fun testLimitedExecutor() = runTest {
         val executor = newFixedThreadPoolContext(targetParallelism, "test")
         val view = executor.limitedParallelism(targetParallelism)
         doStress {
@@ -45,7 +45,7 @@ class LimitedParallelismConcurrentTest : TestBase() {
     }
 
     @Test
-    fun testTaskFairness() = runMtTest {
+    fun testTaskFairness() = runTest {
         val executor = newSingleThreadContext("test")
         val view = executor.limitedParallelism(1)
         val view2 = executor.limitedParallelism(1)

kotlinx-coroutines-core/concurrent/test/RunBlockingTest.kt

@@ -10,7 +10,7 @@ import kotlin.test.*
 class RunBlockingTest : TestBase() {
 
     @Test
-    fun testWithTimeoutBusyWait() = runMtTest {
+    fun testWithTimeoutBusyWait() = runTest {
         val value = withTimeoutOrNull(10) {
             while (isActive) {
                 // Busy wait
@@ -52,7 +52,7 @@ class RunBlockingTest : TestBase() {
     }
 
     @Test
-    fun testOtherDispatcher() = runMtTest {
+    fun testOtherDispatcher() = runTest {
         expect(1)
         val name = "RunBlockingTest.testOtherDispatcher"
         val thread = newSingleThreadContext(name)
@@ -68,7 +68,7 @@ class RunBlockingTest : TestBase() {
     }
 
     @Test
-    fun testCancellation()  = runMtTest {
+    fun testCancellation()  = runTest {
         newFixedThreadPoolContext(2, "testCancellation").use {
             val job = GlobalScope.launch(it) {
                 runBlocking(coroutineContext) {

kotlinx-coroutines-core/concurrent/test/TestBaseExtension.common.kt

@@ -20,7 +20,7 @@ class BroadcastChannelSubStressTest: TestBase() {
     private val receivedTotal = atomic(0L)
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         TestBroadcastChannelKind.values().forEach { kind ->
             println("--- BroadcastChannelSubStressTest $kind")
             val broadcast = kind.create<Long>()

kotlinx-coroutines-core/concurrent/test/channels/BroadcastChannelSubStressTest.kt

@@ -28,7 +28,7 @@ class ChannelCancelUndeliveredElementStressTest : TestBase() {
     private val dUndeliveredCnt = atomic(0)
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         repeat(repeatTimes) {
             val channel = Channel<Int>(1) { dUndeliveredCnt.incrementAndGet() }
             val j1 = launch(Dispatchers.Default) {

kotlinx-coroutines-core/concurrent/test/channels/ChannelCancelUndeliveredElementStressTest.kt

@@ -22,7 +22,7 @@ class ConflatedBroadcastChannelNotifyStressTest : TestBase() {
     private val receivedTotal = atomic(0)
 
     @Test
-    fun testStressNotify()= runMtTest {
+    fun testStressNotify()= runTest {
         println("--- ConflatedBroadcastChannelNotifyStressTest")
         val senders = List(nSenders) { senderId ->
             launch(Dispatchers.Default + CoroutineName("Sender$senderId")) {

kotlinx-coroutines-core/concurrent/test/channels/ConflatedBroadcastChannelNotifyStressTest.kt

@@ -10,7 +10,7 @@ import kotlin.test.*
 class CombineStressTest : TestBase() {
 
     @Test
-    fun testCancellation() = runMtTest {
+    fun testCancellation() = runTest {
         withContext(Dispatchers.Default + CoroutineExceptionHandler { _, _ -> expectUnreached() }) {
             flow {
                 expect(1)
@@ -26,7 +26,7 @@ class CombineStressTest : TestBase() {
     }
 
     @Test
-    fun testFailure() = runMtTest {
+    fun testFailure() = runTest {
         val innerIterations = 100 * stressTestMultiplierSqrt
         val outerIterations = 10 * stressTestMultiplierSqrt
         withContext(Dispatchers.Default + CoroutineExceptionHandler { _, _ -> expectUnreached() }) {

kotlinx-coroutines-core/concurrent/test/flow/CombineStressTest.kt

@@ -12,7 +12,7 @@ import kotlin.test.*
 class FlowCancellationTest : TestBase() {
 
     @Test
-    fun testEmitIsCooperative() = runMtTest {
+    fun testEmitIsCooperative() = runTest {
         val latch = Channel<Unit>(1)
         val job = flow {
             expect(1)
@@ -29,7 +29,7 @@ class FlowCancellationTest : TestBase() {
     }
 
     @Test
-    fun testIsActiveOnCurrentContext() = runMtTest {
+    fun testIsActiveOnCurrentContext() = runTest {
         val latch = Channel<Unit>(1)
         val job = flow<Unit> {
             expect(1)
@@ -46,7 +46,7 @@ class FlowCancellationTest : TestBase() {
     }
 
     @Test
-    fun testFlowWithEmptyContext() = runMtTest {
+    fun testFlowWithEmptyContext() = runTest {
         expect(1)
         withEmptyContext {
             val flow = flow {

kotlinx-coroutines-core/concurrent/test/flow/FlowCancellationTest.kt

@@ -13,7 +13,7 @@ class StateFlowCommonStressTest : TestBase() {
     private val state = MutableStateFlow<Long>(0)
 
     @Test
-    fun testSingleEmitterAndCollector() = runMtTest {
+    fun testSingleEmitterAndCollector() = runTest {
         var collected = 0L
         val collector = launch(Dispatchers.Default) {
             // collect, but abort and collect again after every 1000 values to stress allocation/deallocation

kotlinx-coroutines-core/concurrent/test/flow/StateFlowCommonStressTest.kt

@@ -21,7 +21,7 @@ class StateFlowUpdateCommonTest : TestBase() {
     @Test
     fun testGetAndUpdate() = doTest { getAndUpdate { it + 1 } }
 
-    private fun doTest(increment: MutableStateFlow<Int>.() -> Unit) = runMtTest {
+    private fun doTest(increment: MutableStateFlow<Int>.() -> Unit) = runTest {
         val flow = MutableStateFlow(0)
         val j1 = launch(Dispatchers.Default) {
             repeat(iterations / 2) {

kotlinx-coroutines-core/concurrent/test/flow/StateFlowUpdateCommonTest.kt

@@ -15,7 +15,7 @@ class SelectChannelStressTest: TestBase() {
     private val iterations = (if (isNative) 1_000 else 1_000_000) * stressTestMultiplier
 
     @Test
-    fun testSelectSendResourceCleanupArrayChannel() = runMtTest {
+    fun testSelectSendResourceCleanupArrayChannel() = runTest {
         val channel = Channel<Int>(1)
         expect(1)
         channel.send(-1) // fill the buffer, so all subsequent sends cannot proceed
@@ -29,7 +29,7 @@ class SelectChannelStressTest: TestBase() {
     }
 
     @Test
-    fun testSelectReceiveResourceCleanupArrayChannel() = runMtTest {
+    fun testSelectReceiveResourceCleanupArrayChannel() = runTest {
         val channel = Channel<Int>(1)
         expect(1)
         repeat(iterations) { i ->
@@ -42,7 +42,7 @@ class SelectChannelStressTest: TestBase() {
     }
 
     @Test
-    fun testSelectSendResourceCleanupRendezvousChannel() = runMtTest {
+    fun testSelectSendResourceCleanupRendezvousChannel() = runTest {
         val channel = Channel<Int>(Channel.RENDEZVOUS)
         expect(1)
         repeat(iterations) { i ->
@@ -55,7 +55,7 @@ class SelectChannelStressTest: TestBase() {
     }
 
     @Test
-    fun testSelectReceiveResourceRendezvousChannel() = runMtTest {
+    fun testSelectReceiveResourceRendezvousChannel() = runTest {
         val channel = Channel<Int>(Channel.RENDEZVOUS)
         expect(1)
         repeat(iterations) { i ->

kotlinx-coroutines-core/concurrent/test/selects/SelectChannelStressTest.kt

@@ -14,24 +14,24 @@ class MutexStressTest : TestBase() {
     private val n = (if (isNative) 1_000 else 10_000) * stressTestMultiplier
 
     @Test
-    fun testDefaultDispatcher() = runMtTest { testBody(Dispatchers.Default) }
+    fun testDefaultDispatcher() = runTest { testBody(Dispatchers.Default) }
 
     @Test
-    fun testSingleThreadContext() = runMtTest {
+    fun testSingleThreadContext() = runTest {
         newSingleThreadContext("testSingleThreadContext").use {
             testBody(it)
         }
     }
 
     @Test
-    fun testMultiThreadedContextWithSingleWorker() = runMtTest {
+    fun testMultiThreadedContextWithSingleWorker() = runTest {
         newFixedThreadPoolContext(1, "testMultiThreadedContextWithSingleWorker").use {
             testBody(it)
         }
     }
 
     @Test
-    fun testMultiThreadedContext() = runMtTest {
+    fun testMultiThreadedContext() = runTest {
        newFixedThreadPoolContext(8, "testMultiThreadedContext").use {
             testBody(it)
         }
@@ -56,7 +56,7 @@ class MutexStressTest : TestBase() {
     }
 
     @Test
-    fun stressUnlockCancelRace() = runMtTest {
+    fun stressUnlockCancelRace() = runTest {
         val n = 10_000 * stressTestMultiplier
         val mutex = Mutex(true) // create a locked mutex
         newSingleThreadContext("SemaphoreStressTest").use { pool ->
@@ -86,7 +86,7 @@ class MutexStressTest : TestBase() {
     }
 
     @Test
-    fun stressUnlockCancelRaceWithSelect() = runMtTest {
+    fun stressUnlockCancelRaceWithSelect() = runTest {
         val n = 10_000 * stressTestMultiplier
         val mutex = Mutex(true) // create a locked mutex
         newSingleThreadContext("SemaphoreStressTest").use { pool ->
@@ -119,7 +119,7 @@ class MutexStressTest : TestBase() {
     }
 
     @Test
-    fun testShouldBeUnlockedOnCancellation() = runMtTest {
+    fun testShouldBeUnlockedOnCancellation() = runTest {
         val mutex = Mutex()
         val n = 1000 * stressTestMultiplier
         repeat(n) {