Formatting

Author: bbrockbernd

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

@@ -1,10 +1,6 @@
 package kotlinx.atomicfu.locks
 
 import kotlinx.cinterop.*
-import kotlinx.cinterop.alloc
-import kotlinx.cinterop.free
-import kotlinx.cinterop.pointed
-import kotlinx.cinterop.ptr
 import platform.posix.*
 
 @OptIn(ExperimentalForeignApi::class, UnsafeNumber::class)
@@ -23,15 +19,15 @@ internal actual object ParkingDelegator {
         return ParkingData(mut, cond)
     }
 
-    actual inline fun wait(ref: ParkingData, shouldWait: () -> Boolean){
+    actual inline fun wait(ref: ParkingData, shouldWait: () -> Boolean) {
         callAndVerify { pthread_mutex_lock(ref.mut) }
         try {
             if (shouldWait()) callAndVerify { pthread_cond_wait(ref.cond, ref.mut) }
         } finally {
             callAndVerify { pthread_mutex_unlock(ref.mut) }
         }
     }
-    
+
     actual inline fun timedWait(ref: ParkingData, nanos: Long, shouldWait: () -> Boolean): Unit = memScoped {
         val ts = alloc<timespec>().ptr
 
@@ -68,4 +64,8 @@ internal actual object ParkingDelegator {
         nativeHeap.free(ref.cond)
     }
 }
-internal actual class ParkingData @OptIn(UnsafeNumber::class) constructor(val mut: CPointer<pthread_mutex_t>, val cond: CPointer<pthread_cond_t>)
+
+internal actual class ParkingData @OptIn(UnsafeNumber::class) constructor(
+    val mut: CPointer<pthread_mutex_t>,
+    val cond: CPointer<pthread_cond_t>
+)

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

@@ -1,7 +1,7 @@
 package kotlinx.atomicfu.locks
 
 /**
- * Object that stores references that need to be manually destroyed and deallocated, 
+ * Object that stores references that need to be manually destroyed and deallocated,
  * after native pthread_cond_wait usage.
  */
 internal expect class ParkingData
@@ -12,7 +12,7 @@ internal expect class ParkingData
  */
 internal expect object ParkingDelegator {
     fun createRef(): ParkingData
-    fun wait(ref: ParkingData, shouldWait: () -> Boolean) 
+    fun wait(ref: ParkingData, shouldWait: () -> Boolean)
     fun timedWait(ref: ParkingData, nanos: Long, shouldWait: () -> Boolean)
     fun wake(ref: ParkingData)
     fun destroyRef(ref: ParkingData)
@@ -22,18 +22,18 @@ internal expect object ParkingDelegator {
  * Adds nano seconds to current time in seconds.
  * Clamps for Int.
  */
-internal fun Int.addNanosToSeconds(nanos: Long): Int = 
+internal fun Int.addNanosToSeconds(nanos: Long): Int =
     (this + nanos / 1_000_000_000).coerceIn(Int.MIN_VALUE.toLong(), Int.MAX_VALUE.toLong()).toInt()
 
 /**
  * Adds nano seconds to current time in seconds.
  */
 internal fun Long.addNanosToSeconds(nanos: Long): Long {
-    
+
     // Should never happen as this is checked in `ThreadParker`
     check(nanos >= 0) { "Cannot wait for a negative number of nanoseconds" }
-    val result =  this + nanos / 1_000_000_000
-    
+    val result = this + nanos / 1_000_000_000
+
     // Overflow check: should never happen since this is very far into the future.
     check(!(this xor result < 0 && this >= 0)) { "Nano seconds addition overflowed, current time in seconds is $this" }
     return result

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

@@ -1,10 +1,13 @@
 package kotlinx.atomicfu.locks
 
+import kotlinx.atomicfu.locks.ParkingSupport.currentThreadHandle
+import kotlinx.atomicfu.locks.ParkingSupport.park
+import kotlinx.atomicfu.locks.ParkingSupport.unpark
 import kotlin.time.Duration
 import kotlin.time.TimeMark
 
 /**
- * Parking and unparking support for threads on Kotlin/Native and Kotlin/JVM. 
+ * Parking and unparking support for threads on Kotlin/Native and Kotlin/JVM.
  * Can be used as a building block to create locks and other synchronization primitives.
  *
  * A call to [ParkingSupport.park] or [ParkingSupport.parkUntil] will pause the current thread.
@@ -14,9 +17,9 @@ import kotlin.time.TimeMark
  * - A spurious wakeup
  * - (Only on JVM) The thread was interrupted. The interrupted flag stays set after wakeup.
  * A future call to [park] this thread will return immediately, unless the `Thread.interrupted` flag is cleared.
- * 
+ *
  * The caller is responsible for verifying the reason of wakeup and how to respond accordingly.
- * 
+ *
  * Example usage parking thread:
  * ```Kotlin
  * // publish my parking handle
@@ -26,22 +29,22 @@ import kotlin.time.TimeMark
  *   ParkingSupport.park(Duration.INFINITE)
  * }
  * ```
- * 
+ *
  * Example usage unparker thread:
  * ```Kotlin
  * state.value = WAKE
  * ParkingSupport.unpark(handleReference.value)
  * ```
- * 
+ *
  * PLEASE NOTE: this is a low-level API and should be used with caution.
  * Unless the goal is to create a _synchronization primitive_ like a mutex or semaphore,
  * it is advised to a higher level concurrency API like `kotlinx.coroutines`
  */
 expect object ParkingSupport {
-    
+
     /**
      * Parks the current thread for [timeout] duration.
-     * 
+     *
      * Wakes up in the following cases:
      * - A different thread calls [ParkingSupport.unpark].
      * - The [timeout] is exceeded.
@@ -50,7 +53,7 @@ expect object ParkingSupport {
      * A future call to [park] this thread will return immediately, unless the `Thread.interrupted` flag is cleared.
      */
     fun park(timeout: Duration)
-    
+
     /**
      * Parks the current thread until [deadline] is reached.
      *
@@ -67,21 +70,21 @@ expect object ParkingSupport {
      * Unparks the thread corresponding to [handle].
      * If [unpark] is called while the corresponding thread is not parked, the next [park] call will return immediately
      * — the [ParkingHandle] is unparked ahead of time.
-     * 
-     * A [ParkingHandle] can only _remember_ one pre-unpark attempt at a time. 
-     * Meaning, when two consecutive [unpark] calls are made while the corresponding thread is not parked, 
+     *
+     * A [ParkingHandle] can only _remember_ one pre-unpark attempt at a time.
+     * Meaning, when two consecutive [unpark] calls are made while the corresponding thread is not parked,
      * only the next park call will return immediately — [unpark] calls are not accumulated.
      */
     fun unpark(handle: ParkingHandle)
 
     /**
-     * Returns the [ParkingHandle] corresponding to the current thread. 
+     * Returns the [ParkingHandle] corresponding to the current thread.
      * This [ParkingHandle] should be shared with other threads which allow them to [unpark] the current thread.
-     * 
+     *
      * A [ParkingHandle] is uniquely associated with a specific thread, maintaining a one-to-one correspondence.
-     * When the _same_ thread makes multiple calls to [currentThreadHandle], 
+     * When the _same_ thread makes multiple calls to [currentThreadHandle],
      * it always returns the _same_ [ParkingHandle].
-     * 
+     *
      * Note: as this function returns a unique [ParkingHandle] for each thread it should not be cached or memoized.
      */
     fun currentThreadHandle(): ParkingHandle
@@ -91,7 +94,7 @@ expect object ParkingSupport {
  * A handle allowing to unpark a thread of execution using [ParkingSupport.unpark].
  * There is a one-to-one mapping between threads and parking handles.
  * A handle can be obtained by calling [ParkingSupport.currentThreadHandle].
- * Refer to [ParkingSupport] documentation for more details 
+ * Refer to [ParkingSupport] documentation for more details
  * on how to use [ParkingHandle] and how parking works in general.
  */
 expect class ParkingHandle

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

@@ -6,7 +6,7 @@ import kotlin.time.TimeSource
 
 /**
  * Thread parker for Kotlin/Native based on POSIX calls.
- * Resides in a shared sourceSet with JVM, to be testable with Lincheck. 
+ * Resides in a shared sourceSet with JVM, to be testable with Lincheck.
  * (Which is part of PR #508)
  */
 internal class ThreadParker {
@@ -16,7 +16,7 @@ internal class ThreadParker {
     fun park() = parkWith { data ->
         delegator.wait(data) { state.value is Parked }
     }
-    
+
     fun parkNanos(nanos: Long) {
         val mark = TimeSource.Monotonic.markNow()
         parkWith { data ->
@@ -35,7 +35,7 @@ internal class ThreadParker {
                         delegator.destroyRef(pd)
                         continue
                     }
-                    
+
                     invokeWait(pd)
 
                     while (true) {
@@ -45,7 +45,7 @@ internal class ThreadParker {
                                 delegator.destroyRef(pd)
                                 return
                             }
-                            
+
                             // If other thread is unparking return. Let unparking thread deal with cleanup.
                             is Unparking -> if (state.compareAndSet(changedState, Free)) return
 
@@ -64,7 +64,7 @@ internal class ThreadParker {
                 }
                 // Parker was pre unparked. Set to free and continue.
                 Unparked -> if (state.compareAndSet(Unparked, Free)) return
-                
+
                 // The states below should only be reachable if parking thread has not yet returned.
                 is Parked -> throw IllegalStateException("Thread should not be able to call park when it is already parked")
                 is Unparking -> throw IllegalStateException("Thread should not be able to call park when it is already parked")
@@ -75,14 +75,14 @@ internal class ThreadParker {
     fun unpark() {
         val myUnparkingState = Unparking()
         while (true) {
-            when (val currentState = state.value) { 
-                
+            when (val currentState = state.value) {
+
                 // Is already unparked
                 Unparked -> return
                 is Unparking -> return
-                
+
                 Free -> if (state.compareAndSet(Free, Unparked)) return
-                
+
                 // Is parked -> try unpark
                 is Parked -> if (state.compareAndSet(currentState, myUnparkingState)) {
                     delegator.wake(currentState.data)
@@ -97,6 +97,7 @@ internal class ThreadParker {
 }
 
 private sealed interface ParkingState
+
 // The Parker is pre-unparked. The next park call will change state to Free and return immediately.
 private object Unparked : ParkingState
 

atomicfu/src/concurrentTest/kotlin/kotlinx/atomicfu/locks/BarrierTest.kt

@@ -16,11 +16,15 @@ class BarrierTest {
     private class Arrs(numberOfThreads: Int) {
         val after = AtomicIntArray(numberOfThreads)
         val before = AtomicIntArray(numberOfThreads)
-        init {repeat(numberOfThreads) {
+
+        init {
+            repeat(numberOfThreads) {
                 after[it].value = 0
                 before[it].value = 0
-            }}
+            }
+        }
     }
+
     @Test
     fun testBarrier() {
         repeat(TEST_ITERATIONS) { iteration ->
@@ -60,6 +64,7 @@ private class Barrier(private val parties: Int) {
     init {
         require(parties > 1)
     }
+
     private val count = atomic(0)
     private val waiters = atomicArrayOfNulls<Any?>(parties - 1)
 

atomicfu/src/concurrentTest/kotlin/kotlinx/atomicfu/locks/CyclicBarrierTest.kt

@@ -16,12 +16,15 @@ class CyclicBarrierTest {
     private class Arrs(numberOfThreads: Int) {
         val after = AtomicIntArray(numberOfThreads)
         val before = AtomicIntArray(numberOfThreads)
-        init {repeat(numberOfThreads) {
-            after[it].value = 0
-            before[it].value = 0
-        }}
+
+        init {
+            repeat(numberOfThreads) {
+                after[it].value = 0
+                before[it].value = 0
+            }
+        }
     }
-    
+
     @Test
     fun stressCyclicBarrier() {
         BARRIER_SIZES.forEach { barrierSize ->
@@ -94,8 +97,7 @@ private class MSQueueCyclicBarrier<E> {
             if (curTail.next.compareAndSet(null, node)) {
                 tail.compareAndSet(curTail, node)
                 return node.id
-            }
-            else tail.compareAndSet(curTail, curTail.next.value!!)
+            } else tail.compareAndSet(curTail, curTail.next.value!!)
         }
     }
 
@@ -111,6 +113,7 @@ private class MSQueueCyclicBarrier<E> {
             }
         }
     }
+
     private class Node<E>(var element: E?, val id: Long) {
         val next = atomic<Node<E>?>(null)
     }

atomicfu/src/concurrentTest/kotlin/kotlinx/atomicfu/locks/ExchangerTest.kt

@@ -8,16 +8,16 @@ import kotlin.time.Duration
 private const val N_ITEMS_TO_SWAP = 100_000
 
 class ExchangerTest {
-    
+
     @Test
     fun exchangeTwoLists() {
         val aBefore = List(N_ITEMS_TO_SWAP) { 0 }
         val bBefore = List(N_ITEMS_TO_SWAP) { 1 }
         val aAfter = mutableListOf<Int>()
         val bAfter = mutableListOf<Int>()
-        
+
         val exchanger = Exchanger<Int>()
-        
+
         val at = testThread {
             aBefore.forEachIndexed { i, v ->
                 val item = exchanger.exchange(v)

atomicfu/src/concurrentTest/kotlin/kotlinx/atomicfu/locks/LatchTest.kt

@@ -15,12 +15,15 @@ class LatchTest {
     private class Arrs(numberOfThreads: Int) {
         val after = AtomicIntArray(numberOfThreads)
         val before = AtomicIntArray(numberOfThreads)
-        init {repeat(numberOfThreads) {
-            after[it].value = 0
-            before[it].value = 0
-        }}
+
+        init {
+            repeat(numberOfThreads) {
+                after[it].value = 0
+                before[it].value = 0
+            }
+        }
     }
-    
+
     @Test
     fun latchTest() {
         repeat(TEST_ITERATIONS) { iteration ->
@@ -90,8 +93,7 @@ private class MSQueueLatch<E> {
             if (curTail.next.compareAndSet(null, node)) {
                 tail.compareAndSet(curTail, node)
                 return
-            }
-            else tail.compareAndSet(curTail, curTail.next.value!!)
+            } else tail.compareAndSet(curTail, curTail.next.value!!)
         }
     }
 
@@ -106,6 +108,7 @@ private class MSQueueLatch<E> {
             }
         }
     }
+
     private class Node<E>(var element: E?) {
         val next = atomic<Node<E>?>(null)
     }

atomicfu/src/concurrentTest/kotlin/kotlinx/atomicfu/locks/TestThread.kt

@@ -1,6 +1,6 @@
 package kotlinx.atomicfu.locks
 
-internal fun testThread(doConcurrent: () ->  Unit): TestThread = TestThread(doConcurrent)
+internal fun testThread(doConcurrent: () -> Unit): TestThread = TestThread(doConcurrent)
 
 internal expect class TestThread(toDo: () -> Unit) {
     fun join()