Thread parking for Kotlin/Common

atomicfu/api/atomicfu.api

@@ -135,3 +135,21 @@ public final class kotlinx/atomicfu/TraceKt {
 	public static final fun named (Lkotlinx/atomicfu/TraceBase;Ljava/lang/String;)Lkotlinx/atomicfu/TraceBase;
 }
 
+public final class kotlinx/atomicfu/parking/KThread {
+	public static final field Companion Lkotlinx/atomicfu/parking/KThread$Companion;
+}
+
+public final class kotlinx/atomicfu/parking/KThread$Companion {
+	public final fun currentThread ()Lkotlinx/atomicfu/parking/KThread;
+}
+
+public final class kotlinx/atomicfu/parking/Parker {
+	public static final field Companion Lkotlinx/atomicfu/parking/Parker$Companion;
+}
+
+public final class kotlinx/atomicfu/parking/Parker$Companion {
+	public final fun park ()V
+	public final fun parkNanos (J)V
+	public final fun unpark (Lkotlinx/atomicfu/parking/KThread;)V
+}
+

atomicfu/build.gradle.kts

@@ -10,7 +10,33 @@ plugins {
     id("kotlin-multiplatform-publish-conventions")
 }
 
+// Support of all non-deprecated targets from the official tier list: https://kotlinlang.org/docs/native-target-support.html
 kotlin {
+    // Tier 1
+    macosX64()
+    macosArm64()
+    iosSimulatorArm64()
+    iosX64()
+
+    // Tier 2
+    linuxX64()
+    linuxArm64()
+    watchosSimulatorArm64()
+    watchosX64()
+    watchosArm32()
+    watchosArm64()
+    tvosSimulatorArm64()
+    tvosX64()
+    tvosArm64()
+    iosArm64()
+
+    // Tier 3
+    androidNativeArm32()
+    androidNativeArm64()
+    androidNativeX86()
+    androidNativeX64()
+    mingwX64()
+    watchosDeviceArm64()
 
     // JS -- always
     js(IR) {
@@ -33,6 +59,12 @@ kotlin {
     wasmWasi {
         nodejs()
     }
+
+    @Suppress("DEPRECATION") //https://github.com/Kotlin/kotlinx-atomicfu/issues/207
+    linuxArm32Hfp()
+
+    @OptIn(ExperimentalKotlinGradlePluginApi::class)
+    applyDefaultHierarchyTemplate()
 
     sourceSets {
         commonMain.dependencies {
@@ -93,87 +125,19 @@ kotlin {
                 implementation(libs.junit.junit)
             }
         }
-    }
-}
-
-// Support of all non-deprecated targets from the official tier list: https://kotlinlang.org/docs/native-target-support.html
-kotlin {
-    // Tier 1
-    macosX64()
-    macosArm64()
-    iosSimulatorArm64()
-    iosX64()
-
-    // Tier 2
-    linuxX64()
-    linuxArm64()
-    watchosSimulatorArm64()
-    watchosX64()
-    watchosArm32()
-    watchosArm64()
-    tvosSimulatorArm64()
-    tvosX64()
-    tvosArm64()
-    iosArm64()
-
-    // Tier 3
-    androidNativeArm32()
-    androidNativeArm64()
-    androidNativeX86()
-    androidNativeX64()
-    mingwX64()
-    watchosDeviceArm64()
-
-    @Suppress("DEPRECATION") //https://github.com/Kotlin/kotlinx-atomicfu/issues/207
-    linuxArm32Hfp()
-
-    @OptIn(ExperimentalKotlinGradlePluginApi::class)
-    applyDefaultHierarchyTemplate {
-        group("native") {
-            group("nativeUnixLike") {
-                withLinux()
-                withApple()
-            }
-        }
-        group("androidNative32Bit") {
-            withAndroidNativeX86()
-            withCompilations { compilation ->
-                (compilation.target as? KotlinNativeTarget)?.konanTarget?.name == "android_arm32"
-            }
-        }
-        group("androidNative64Bit") {
-            withAndroidNativeArm64()
-            withAndroidNativeX64()
-        }
-
-    }
-
-    sourceSets {
-        val nativeUnixLikeMain by getting {
-            kotlin.srcDir("src/nativeUnixLikeMain/kotlin")
-            dependsOn(nativeMain.get())
-        }
-
-        val androidNative32BitMain by getting {
-            kotlin.srcDir("src/androidNative32BitMain/kotlin")
-            dependsOn(nativeMain.get())
-        }
-
-        val androidNative64BitMain by getting {
-            kotlin.srcDir("src/androidNative64BitMain/kotlin")
-            dependsOn(nativeMain.get())
-        }
-
-        val androidNative32BitTest by getting {
-            kotlin.srcDir("src/androidNative32BitTest/kotlin")
-            dependsOn(nativeTest.get())
-        }
-
-        val androidNative64BitTest by getting {
-            kotlin.srcDir("src/androidNative64BitTest/kotlin")
-            dependsOn(nativeTest.get())
-        }
-
+
+        val concurrentMain by creating { dependsOn(commonMain.get()) }
+        val concurrentTest by creating { dependsOn(commonTest.get()) }
+
+        val jvmMain by getting { dependsOn(concurrentMain) }
+        val jvmTest by getting { dependsOn(concurrentTest) }
+
+        val nativeMain by getting { dependsOn(concurrentMain) }
+        val nativeTest by getting { dependsOn(concurrentTest) }
+
+        val nativeUnixLikeMain by creating { dependsOn(nativeMain) }
+        val appleMain by getting { dependsOn(nativeUnixLikeMain) }
+        val linuxMain by getting { dependsOn(nativeUnixLikeMain) }
     }
 
     // atomicfu-cinterop-interop.klib with an empty interop.def file will still be published for compatibility reasons (see KT-68411)
@@ -189,6 +153,7 @@ kotlin {
     }
 }
 
+
 val transformer: Configuration by configurations.creating
 
 dependencies {

atomicfu/src/androidNative32BitMain/kotlin/kotlinx/atomicfu/locks/NativeMutexNode.kt → atomicfu/src/androidNativeMain/kotlin/kotlinx/atomicfu/locks/NativeMutexNode.kt

@@ -4,6 +4,7 @@ import kotlinx.cinterop.*
 import platform.posix.*
 import kotlin.concurrent.Volatile
 
+@OptIn(UnsafeNumber::class)
 public actual class NativeMutexNode {
 
     @Volatile

atomicfu/src/androidNativeMain/kotlin/kotlinx/atomicfu/parking/PosixParkingDelegator.kt

@@ -0,0 +1,57 @@
+package kotlinx.atomicfu.parking
+
+import kotlinx.cinterop.*
+import kotlinx.cinterop.alloc
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.ptr
+import platform.posix.*
+import kotlin.math.min
+
+@OptIn(ExperimentalForeignApi::class, UnsafeNumber::class)
+internal actual object ParkingDelegator {
+    actual fun createRef(): ParkingData {
+        val mut = nativeHeap.alloc<pthread_mutex_t>().ptr
+        val cond = nativeHeap.alloc<pthread_cond_t>().ptr
+        callAndVerifyNative(0) { pthread_mutex_init(mut, null) }
+        callAndVerifyNative(0) { pthread_cond_init(cond, null) }
+        return ParkingData(mut, cond)
+    }
+
+    actual fun wait(ref: ParkingData, shouldWait: () -> Boolean){
+        callAndVerifyNative(0) { pthread_mutex_lock(ref.mut) }
+        if (shouldWait()) callAndVerifyNative(0) { pthread_cond_wait(ref.cond, ref.mut) }
+        callAndVerifyNative(0) { pthread_mutex_unlock(ref.mut) }
+    }
+
+    actual fun timedWait(ref: ParkingData, nanos: Long, shouldWait: () -> Boolean): Unit = memScoped {
+        val ts = alloc<timespec>().ptr
+
+        // Add nanos to current time
+        clock_gettime(CLOCK_REALTIME.convert(), ts)
+        ts.pointed.tv_sec = min(ts.pointed.tv_sec + nanos / 1_000_000_000, Int.MAX_VALUE.toLong()).convert()
+        ts.pointed.tv_nsec = (ts.pointed.tv_nsec + nanos % 1_000_000_000).convert()
+        //Fix overflow
+        if (ts.pointed.tv_nsec >= 1_000_000_000) {
+            if (ts.pointed.tv_sec.convert<Int>() != Int.MAX_VALUE) ts.pointed.tv_sec += 1
+            ts.pointed.tv_nsec -= 1_000_000_000
+        }
+        callAndVerifyNative(0) { pthread_mutex_lock(ref.mut) }
+        if (shouldWait()) callAndVerifyNative(0, ETIMEDOUT) { pthread_cond_timedwait(ref.cond, ref.mut, ts) }
+        callAndVerifyNative(0) { pthread_mutex_unlock(ref.mut) }
+    }
+
+    actual fun wake(ref: ParkingData) {
+        callAndVerifyNative(0) { pthread_mutex_lock(ref.mut) }
+        callAndVerifyNative(0) { pthread_cond_signal(ref.cond) }
+        callAndVerifyNative(0) { pthread_mutex_unlock(ref.mut) }
+    }
+
+    actual fun destroyRef(ref: ParkingData) {
+        callAndVerifyNative(0) { pthread_mutex_destroy(ref.mut) }
+        callAndVerifyNative(0) { pthread_cond_destroy(ref.cond) }
+        nativeHeap.free(ref.mut)
+        nativeHeap.free(ref.cond)
+    }
+
+}
+internal actual class ParkingData(val mut: CPointer<pthread_mutex_t>, val cond: CPointer<pthread_cond_t>)

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

@@ -0,0 +1,39 @@
+package kotlinx.atomicfu.parking
+
+/**
+ * Holds reference to the current thread, allows for unparking it by calling [Parker.unpark].
+ * Reference can be obtained by calling [currentThread].
+ */
+expect class KThread private constructor() {
+    companion object {
+        fun currentThread(): KThread
+    }
+}
+
+/**
+ * Parking API, uses posix on native and LockSupport on JVM.
+ */
+expect class Parker private constructor() {
+    companion object {
+        /**
+         * Parks the current thread, until an [unpark] call is made.
+         * Does not park the current thread if [unpark] was called before [park].
+         */
+        fun park(): Unit
+
+        /**
+         * Parks if [unpark] was not called before, and wakes when either an [unpark] call is made 
+         * or [nanos] nanoseconds have passed.
+         */
+        fun parkNanos(nanos: Long): Unit
+
+        /**
+         * Unparks thread [kThread] when parked, otherwise prevents the next [park] call from parking the thread.
+         * Does nothing when the thread is already pre-unparked.
+         */
+        fun unpark(kThread: KThread): Unit
+    }
+}
+
+internal expect fun currentThreadId(): Long 
+

atomicfu/src/concurrentMain/kotlin/kotlinx/atomicfu/parking/ParkingDelegator.kt

@@ -0,0 +1,16 @@
+package kotlinx.atomicfu.parking
+
+/**
+ * Internal utility that delegates the thread suspending and resuming to pthread_cond_wait on native.
+ * On jvm delegates to LockSupport.Park.
+ */
+
+internal expect class ParkingData
+
+internal expect object ParkingDelegator {
+    fun createRef(): ParkingData
+    fun wait(ref: ParkingData, shouldWait: () -> Boolean) 
+    fun timedWait(ref: ParkingData, nanos: Long, shouldWait: () -> Boolean)
+    fun wake(ref: ParkingData)
+    fun destroyRef(ref: ParkingData)
+}