Thread parking for Kotlin/Common

atomicfu/api/atomicfu.api

@@ -135,3 +135,25 @@ 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/KThreadKt {
+	public static final fun currentThreadId ()J
+}
+
+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

@@ -1,3 +1,4 @@
+import org.gradle.internal.impldep.org.junit.experimental.categories.Categories.CategoryFilter.exclude
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
@@ -93,6 +94,12 @@ kotlin {
                 implementation(libs.junit.junit)
             }
         }
+
+        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) }
     }
 }
 
@@ -128,50 +135,60 @@ kotlin {
     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()
-        }
-
-    }
+    applyDefaultHierarchyTemplate() 
 
     sourceSets {
-        val nativeUnixLikeMain by getting {
-            kotlin.srcDir("src/nativeUnixLikeMain/kotlin")
-            dependsOn(nativeMain.get())
+
+        val concurrentMain by getting {}
+        val concurrentTest by getting {}
+        val nativeMain by getting { dependsOn(concurrentMain) }
+        val nativeTest by getting { dependsOn(concurrentTest) }
+
+        val nativeUnixLikeMain by creating { dependsOn(nativeMain) }
+
+
+        val androidNative64BitMain by creating { dependsOn(nativeMain) }
+        androidNative64BitMain.also {
+            androidNativeArm64Main.get().dependsOn(it)
+            androidNativeX64Main.get().dependsOn(it)
+        }
+
+        val androidNative32BitMain by creating { dependsOn(nativeMain) }
+        androidNative32BitMain.let {
+            androidNativeArm32Main.get().dependsOn(it)
+            androidNativeX86Main.get().dependsOn(it)
         }
 
-        val androidNative32BitMain by getting {
-            kotlin.srcDir("src/androidNative32BitMain/kotlin")
-            dependsOn(nativeMain.get())
+        val linux64Main by creating { dependsOn(nativeUnixLikeMain) }
+        linux64Main.let {
+            linuxX64Main.get().dependsOn(it)
+            linuxArm64Main.get().dependsOn(it)
         }
 
-        val androidNative64BitMain by getting {
-            kotlin.srcDir("src/androidNative64BitMain/kotlin")
-            dependsOn(nativeMain.get())
+        val linux32Main by creating { dependsOn(nativeUnixLikeMain) }
+        linux32Main.let {
+            linuxArm32HfpMain.get().dependsOn(it)
         }
 
-        val androidNative32BitTest by getting {
-            kotlin.srcDir("src/androidNative32BitTest/kotlin")
-            dependsOn(nativeTest.get())
+        val apple64Main by creating { dependsOn(nativeUnixLikeMain) }
+        apple64Main.let {
+            watchosDeviceArm64Main.get().dependsOn(it)
+            iosArm64Main.get().dependsOn(it)
+            tvosArm64Main.get().dependsOn(it)
+            tvosX64Main.get().dependsOn(it)
+            tvosSimulatorArm64Main.get().dependsOn(it)
+            watchosX64Main.get().dependsOn(it)
+            watchosSimulatorArm64Main.get().dependsOn(it)
+            iosX64Main.get().dependsOn(it)
+            iosSimulatorArm64Main.get().dependsOn(it)
+            macosX64Main.get().dependsOn(it)
+            macosArm64Main.get().dependsOn(it)
         }
 
-        val androidNative64BitTest by getting {
-            kotlin.srcDir("src/androidNative64BitTest/kotlin")
-            dependsOn(nativeTest.get())
+        val apple32Main by creating { dependsOn(nativeUnixLikeMain) }
+        apple32Main.let {
+            watchosArm32Main.get().dependsOn(it)
+            watchosArm64Main.get().dependsOn(it) // Uses Int for timespec
         }
 
     }

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

@@ -0,0 +1,59 @@
+package kotlinx.atomicfu.parking
+
+import kotlinx.cinterop.*
+import kotlinx.cinterop.alloc
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.ptr
+import platform.posix.*
+
+@OptIn(ExperimentalForeignApi::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.toInt(), ts)
+        ts.pointed.tv_sec += nanos.toInt() / 1_000_000_000
+        ts.pointed.tv_nsec += nanos.toInt() % 1_000_000_000
+
+        //Fix overflow
+        if (ts.pointed.tv_nsec >= 1_000_000_000) {
+            ts.pointed.tv_sec += 1
+            ts.pointed.tv_nsec -= 1_000_000_000
+        }
+        var rc = 0
+        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/androidNative64BitMain/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.*
+
+@OptIn(ExperimentalForeignApi::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.toInt(), ts)
+        ts.pointed.tv_sec += nanos / 1_000_000_000
+        ts.pointed.tv_nsec += nanos % 1_000_000_000
+
+        //Fix overflow
+        if (ts.pointed.tv_nsec >= 1_000_000_000) {
+            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/apple32Main/kotlin/kotlinx/atomicfu/parking/PosixParkingDelegator.kt

@@ -0,0 +1,58 @@
+package kotlinx.atomicfu.parking
+
+import kotlinx.cinterop.*
+import kotlinx.cinterop.alloc
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.ptr
+import platform.posix.*
+
+@OptIn(ExperimentalForeignApi::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.toUInt(), ts)
+        ts.pointed.tv_sec += nanos.toInt() / 1_000_000_000
+        ts.pointed.tv_nsec += nanos.toInt() % 1_000_000_000
+
+        //Fix overflow
+        if (ts.pointed.tv_nsec >= 1_000_000_000) {
+            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/apple64Main/kotlin/kotlinx/atomicfu/parking/PosixParkingDelegator.kt

@@ -0,0 +1,60 @@
+package kotlinx.atomicfu.parking
+
+import kotlinx.atomicfu.AtomicBoolean
+import kotlinx.atomicfu.atomic
+import kotlinx.cinterop.*
+import kotlinx.cinterop.alloc
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.ptr
+import platform.posix.*
+import kotlin.toUInt
+
+@OptIn(ExperimentalForeignApi::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.toUInt(), ts)
+        ts.pointed.tv_sec += nanos / 1_000_000_000
+        ts.pointed.tv_nsec += nanos % 1_000_000_000
+
+        //Fix overflow
+        if (ts.pointed.tv_nsec >= 1_000_000_000) {
+            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>)