Fix lincheck (it doesn't support thread locals)

Author: bbrockbernd

atomicfu/src/concurrentMain/kotlin/kotlinx/atomicfu/locks/Mutex.kt

@@ -153,27 +153,25 @@ internal class NativeMutex {
                 when (parker.value) {
                     Empty -> if (parker.compareAndSet(Empty, KThread.currentThread())) Parker.park()
                     is KThread -> Parker.park()
-                    Woken -> return
+                    Awoken -> return
                 }
             }
         }
 
         fun nodeWake() {
             while (true) {
                 when (val currentState = parker.value) {
-                    Empty -> if (parker.compareAndSet(Empty, Woken)) return
-                    is KThread -> if (parker.compareAndSet(currentState, Woken)) {
+                    Empty -> if (parker.compareAndSet(Empty, Awoken)) return
+                    is KThread -> if (parker.compareAndSet(currentState, Awoken)) {
                         Parker.unpark(currentState)
                         return
                     }
-                    Woken -> throw IllegalStateException("Node is already woken")
+                    Awoken -> throw IllegalStateException("Node is already woken")
                 }
             }
         }
     }
 
     private object Empty 
-    private object Woken
-    
-    
+    private object Awoken
 }

atomicfu/src/jvmMain/kotlin/kotlinx/atomicfu/parking/KThread.kt

@@ -1,7 +1,7 @@
 package kotlinx.atomicfu.parking
 
 actual class KThread internal actual constructor() {
-    internal val parker = ThreadParker(this)
+    internal var parker = ThreadParker(this)
     actual companion object {
         actual fun currentThread(): KThread = localKThread.get()
     }

atomicfu/src/jvmTest/kotlin/kotlinx/atomicfu/locks/NativeMutexLincheckReentrantTest.kt

@@ -1,8 +1,12 @@
+import kotlinx.atomicfu.locks.Mutex
 import kotlinx.atomicfu.locks.NativeMutex
+import kotlinx.atomicfu.parking.KThread
+import kotlinx.atomicfu.parking.ThreadParker
 import org.jetbrains.kotlinx.lincheck.annotations.Operation
 import org.jetbrains.kotlinx.lincheck.check
 import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.ModelCheckingOptions
 import org.jetbrains.kotlinx.lincheck.util.LoggingLevel
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.test.Test
 
 class NativeMutexLincheckReentrantTest {
@@ -13,8 +17,9 @@ class NativeMutexLincheckReentrantTest {
         fun inc(): Int = ++value
         fun get() = value
     }
-    private val lock = NativeMutex()
     private val counter = Counter()
+    private val lock = NativeMutex()
+    private val resetThreadParkers = ConcurrentHashMap.newKeySet<Long>()
 
     @Test
     fun modelCheckingTest(): Unit = ModelCheckingOptions()
@@ -30,6 +35,8 @@ class NativeMutexLincheckReentrantTest {
 
     @Operation
     fun inc(): Int {
+        if (resetThreadParkers.add(Thread.currentThread().id))
+            KThread.currentThread().parker = ThreadParker(KThread.currentThread())
         lock.lock()
         if (!lock.tryLock()) throw IllegalStateException("couldnt reent with trylock")
         if (!lock.tryLock()) throw IllegalStateException("couldnt reent with trylock")
@@ -42,6 +49,8 @@ class NativeMutexLincheckReentrantTest {
 
     @Operation
     fun get(): Int {
+        if (resetThreadParkers.add(Thread.currentThread().id))
+            KThread.currentThread().parker = ThreadParker(KThread.currentThread())
         lock.lock()
         if (!lock.tryLock()) throw IllegalStateException("couldnt reent with trylock")
         if (!lock.tryLock()) throw IllegalStateException("couldnt reent with trylock")

atomicfu/src/jvmTest/kotlin/kotlinx/atomicfu/locks/NativeMutexLincheckTest.kt

@@ -1,8 +1,11 @@
 import kotlinx.atomicfu.locks.NativeMutex
+import kotlinx.atomicfu.parking.KThread
+import kotlinx.atomicfu.parking.ThreadParker
 import org.jetbrains.kotlinx.lincheck.annotations.Operation
 import org.jetbrains.kotlinx.lincheck.check
 import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.ModelCheckingOptions
 import org.jetbrains.kotlinx.lincheck.util.LoggingLevel
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.test.Test
 
 class NativeMutexLincheckTest {
@@ -13,8 +16,9 @@ class NativeMutexLincheckTest {
         fun inc(): Int = ++value
         fun get() = value
     }
-    private val lock = NativeMutex()
     private val counter = Counter()
+    private val lock = NativeMutex()
+    private val resetThreadParkers = ConcurrentHashMap.newKeySet<Long>()
 
     @Test
     fun modelCheckingTest(): Unit = ModelCheckingOptions()
@@ -30,13 +34,17 @@ class NativeMutexLincheckTest {
 
     @Operation
     fun inc() {
+        if (resetThreadParkers.add(Thread.currentThread().id)) 
+            KThread.currentThread().parker = ThreadParker(KThread.currentThread())
         lock.lock()
         counter.inc()
         lock.unlock()
     }
 
     @Operation
     fun get() {
+        if (resetThreadParkers.add(Thread.currentThread().id))
+            KThread.currentThread().parker = ThreadParker(KThread.currentThread())
         lock.lock()
         counter.get()
         lock.unlock()