Update linearizability tests

Author: qwwdfsad

core/kotlinx-coroutines-core/src/internal/LockFreeTaskQueue.kt

@@ -67,6 +67,9 @@ internal open class LockFreeTaskQueue<E : Any>(
 
     // Used for validation in tests only
     fun <R> map(transform: (E) -> R): List<R> = _cur.value.map(transform)
+
+    // Used for validation in tests only
+    fun isClosed(): Boolean = _cur.value.isClosed()
 }
 
 /**
@@ -262,6 +265,9 @@ internal class LockFreeTaskQueueCore<E : Any>(
         return res
     }
 
+    // Used for validation in tests only
+    fun isClosed(): Boolean = _state.value and CLOSED_MASK != 0L
+
 
     // Instance of this class is placed into array when we have to copy array, but addLast is in progress --
     // it had already reserved a slot in the array (with null) and have not yet put its value there.

core/kotlinx-coroutines-core/test/linearizability/ChannelIsClosedLinearizabilityTest.kt

@@ -44,11 +44,28 @@ class ChannelIsClosedLinearizabilityTest : TestBase() {
     @Test
     fun testLinearizability() {
         val options = StressOptions()
-            .iterations(100)
-            .invocationsPerIteration(1000 * stressTestMultiplier)
+            .iterations(100 * stressTestMultiplierSqrt)
+            .invocationsPerIteration(1000 * stressTestMultiplierSqrt)
             .threads(3)
             .verifier(LinVerifier::class.java)
 
         LinChecker.check(ChannelIsClosedLinearizabilityTest::class.java, options)
     }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as ChannelIsClosedLinearizabilityTest
+
+        if (channel != other.channel) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return channel.hashCode()
+    }
+
+
 }

core/kotlinx-coroutines-core/test/linearizability/ChannelLinearizabilityTest.kt

@@ -71,8 +71,8 @@ class ChannelLinearizabilityTest : TestBase() {
     private fun runTest(capacity: Int) {
         ChannelLinearizabilityTest.capacity = capacity
         val options = StressOptions()
-            .iterations(100)
-            .invocationsPerIteration(1000 * stressTestMultiplier)
+            .iterations(100 * stressTestMultiplierSqrt)
+            .invocationsPerIteration(1000 * stressTestMultiplierSqrt)
             .threads(3)
             .verifier(LinVerifier::class.java)
         LinChecker.check(ChannelLinearizabilityTest::class.java, options)

core/kotlinx-coroutines-core/test/linearizability/LockFreeListLinearizabilityTest.kt

@@ -46,8 +46,8 @@ class LockFreeListLinearizabilityTest : TestBase() {
     @Test
     fun testAddRemoveLinearizability() {
         val options = StressOptions()
-            .iterations(100)
-            .invocationsPerIteration(1000 * stressTestMultiplier)
+            .iterations(100 * stressTestMultiplierSqrt)
+            .invocationsPerIteration(1000 * stressTestMultiplierSqrt)
             .threads(3)
         LinChecker.check(LockFreeListLinearizabilityTest::class.java, options)
     }

core/kotlinx-coroutines-core/test/linearizability/LockFreeTaskQueueLinearizabilityTest.kt

@@ -13,15 +13,46 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.internal.*
 import kotlin.test.*
 
+internal data class Snapshot(val elements: List<Int>, val isClosed: Boolean) {
+    constructor(q: LockFreeTaskQueue<Int>) : this(q.map { it }, q.isClosed())
+}
+
 @OpGroupConfig.OpGroupConfigs(OpGroupConfig(name = "consumer", nonParallel = true))
 @Param(name = "value", gen = IntGen::class, conf = "1:3")
-class LockFreeTaskQueueLinearizabilityTest : TestBase() {
+class LockFreeTaskQueueLinearizabilityTestSC : LockFreeTaskQueueLinearizabilityTestBase() {
+    private val q: LockFreeTaskQueue<Int> = LockFreeTaskQueue(singleConsumer = true)
+
+    @Operation
+    fun close() = q.close()
+
+    @Operation
+    fun addLast(@Param(name = "value") value: Int) = q.addLast(value)
 
-    private companion object {
-        var singleConsumer = false
+    /**
+     * Note, that removeFirstOrNull is not linearizable w.r.t. to addLast, so here
+     * we test only linearizability of close.
+     */
+//    @Operation(group = "consumer")
+//    fun removeFirstOrNull() = q.removeFirstOrNull()
+
+    @Test
+    fun testSC() = linTest()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as LockFreeTaskQueueLinearizabilityTestSC
+
+        return Snapshot(q) == Snapshot(other.q)
     }
 
-    private val q: LockFreeTaskQueue<Int> = LockFreeTaskQueue(singleConsumer)
+    override fun hashCode(): Int = Snapshot(q).hashCode()
+}
+
+@Param(name = "value", gen = IntGen::class, conf = "1:3")
+class LockFreeTaskQueueLinearizabilityTestMC : LockFreeTaskQueueLinearizabilityTestBase() {
+    private val q: LockFreeTaskQueue<Int> = LockFreeTaskQueue(singleConsumer = false)
 
     @Operation
     fun close() = q.close()
@@ -37,22 +68,26 @@ class LockFreeTaskQueueLinearizabilityTest : TestBase() {
 //    fun removeFirstOrNull() = q.removeFirstOrNull()
 
     @Test
-    fun testLinearizabilitySC() {
-        singleConsumer = true
-        linTest()
-    }
+    fun testMC() = linTest()
 
-    @Test
-    fun testLinearizabilityMC() {
-        singleConsumer = false
-        linTest()
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as LockFreeTaskQueueLinearizabilityTestMC
+
+        return Snapshot(q) == Snapshot(other.q)
     }
 
-    private fun linTest() {
+    override fun hashCode(): Int = Snapshot(q).hashCode()
+}
+
+open class LockFreeTaskQueueLinearizabilityTestBase : TestBase() {
+    fun linTest() {
         val options = StressOptions()
             .iterations(100 * stressTestMultiplierSqrt)
             .invocationsPerIteration(1000 * stressTestMultiplierSqrt)
-            .threads(3)
-        LinChecker.check(LockFreeTaskQueueLinearizabilityTest::class.java, options)
+            .threads(2)
+        LinChecker.check(this::class.java, options)
     }
 }