Generalize the concept of list closing to any number of levels

Author: dkhalanskyjb

kotlinx-coroutines-core/common/src/JobSupport.kt

@@ -320,7 +320,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     private fun notifyCancelling(list: NodeList, cause: Throwable) {
         // first cancel our own children
         onCancelling(cause)
-        list.closeForSome()
+        list.close(LIST_CANCELLATION_PERMISSION)
         notifyHandlers<JobCancellingNode>(list, cause)
         // then cancel parent
         cancelParent(cause) // tentative cancellation -- does not matter if there is no parent
@@ -353,7 +353,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     }
 
     private fun NodeList.notifyCompletion(cause: Throwable?) {
-        close()
+        close(LIST_MAX_PERMISSION)
         notifyHandlers<JobNode>(this, cause)
     }
 
@@ -466,13 +466,13 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             if (onCancelling) {
                 val rootCause = (state as? Finishing)?.let { synchronized(it) { it.rootCause } }
                 if (rootCause == null) {
-                    list.addLast(node, allowedAfterPartialClosing = false)
+                    list.addLast(node, LIST_CANCELLATION_PERMISSION)
                 } else {
                     if (invokeImmediately) handler.invoke(rootCause)
                     return NonDisposableHandle
                 }
             } else {
-                list.addLast(node, allowedAfterPartialClosing = true)
+                list.addLast(node, LIST_MAX_PERMISSION)
             }
         }
         when {
@@ -987,7 +987,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
                     // or we are adding a child to a coroutine that is not completing yet
                     if (maybeRootCause == null || !state.isCompleting) {
                         // Note: add node the list while holding lock on state (make sure it cannot change)
-                        if (!list.addLast(node, allowedAfterPartialClosing = true))
+                        if (!list.addLast(node, LIST_MAX_PERMISSION))
                             return@tryPutNodeIntoList false // retry
                         // just return the node if we don't have to invoke the handler (not cancelling yet)
                         rootCause = maybeRootCause ?: return@tryPutNodeIntoList true
@@ -1000,7 +1000,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
                 }
                 node.invoke(rootCause)
                 return handle
-            } else list.addLast(node, allowedAfterPartialClosing = true).also { success ->
+            } else list.addLast(node, LIST_MAX_PERMISSION).also { success ->
                 if (success) {
                     /** Handling the following case:
                      * - A child requested to be added to the list;
@@ -1347,6 +1347,9 @@ private val SEALED = Symbol("SEALED")
 private val EMPTY_NEW = Empty(false)
 private val EMPTY_ACTIVE = Empty(true)
 
+private const val LIST_MAX_PERMISSION = Int.MAX_VALUE
+private const val LIST_CANCELLATION_PERMISSION = 0
+
 private class Empty(override val isActive: Boolean) : Incomplete {
     override val list: NodeList? get() = null
     override fun toString(): String = "Empty{${if (isActive) "Active" else "New" }}"

kotlinx-coroutines-core/common/src/internal/LockFreeLinkedList.common.kt

@@ -7,11 +7,14 @@ public expect open class LockFreeLinkedListNode() {
     public val isRemoved: Boolean
     public val nextNode: LockFreeLinkedListNode
     public val prevNode: LockFreeLinkedListNode
-    public fun addLast(node: LockFreeLinkedListNode, allowedAfterPartialClosing: Boolean): Boolean
+    public fun addLast(node: LockFreeLinkedListNode, clearanceLevel: Int): Boolean
     public fun addOneIfEmpty(node: LockFreeLinkedListNode): Boolean
     public open fun remove(): Boolean
-    public fun close()
-    public fun closeForSome()
+
+    /**
+     * Closes the list for [maxForbidden] and all numbers below.
+     */
+    public fun close(maxForbidden: Int)
 
 }
 

kotlinx-coroutines-core/concurrent/src/internal/LockFreeLinkedList.kt

@@ -80,28 +80,22 @@ public actual open class LockFreeLinkedListNode {
     /**
      * Adds last item to this list. Returns `false` if the list is closed.
      */
-    public actual fun addLast(node: Node, allowedAfterPartialClosing: Boolean): Boolean {
+    public actual fun addLast(node: Node, clearanceLevel: Int): Boolean {
         while (true) { // lock-free loop on prev.next
             val currentPrev = prevNode
             return when {
-                currentPrev is ListClosedForAll -> false
-                currentPrev is ListClosedForSome ->
-                    allowedAfterPartialClosing && currentPrev.addLast(node, allowedAfterPartialClosing)
+                currentPrev is ListClosed ->
+                    currentPrev.maxForbidden < clearanceLevel && currentPrev.addLast(node, clearanceLevel)
                 currentPrev.addNext(node, this) -> true
                 else -> continue
             }
         }
     }
 
-    /**
-     * Forbids adding some of the new items to this list.
-     */
-    public actual fun closeForSome() { addLast(ListClosedForSome(), allowedAfterPartialClosing = false) }
-
     /**
      * Forbids adding new items to this list.
      */
-    public actual fun close() { addLast(ListClosedForAll(), allowedAfterPartialClosing = true) }
+    public actual fun close(maxForbidden: Int) { addLast(ListClosed(maxForbidden), maxForbidden) }
 
     /**
      * Given:
@@ -291,6 +285,4 @@ public actual open class LockFreeLinkedListHead : LockFreeLinkedListNode() {
     override val isRemoved: Boolean get() = false
 }
 
-private class ListClosedForSome: LockFreeLinkedListNode()
-
-private class ListClosedForAll: LockFreeLinkedListNode()
+private class ListClosed(val maxForbidden: Int): LockFreeLinkedListNode()

kotlinx-coroutines-core/jsAndWasmShared/src/internal/LinkedList.kt

@@ -22,9 +22,8 @@ public open class LinkedListNode : DisposableHandle {
     public inline val prevNode get() = _prev
     public inline val isRemoved get() = _removed
 
-    public fun addLast(node: Node, allowedAfterPartialClosing: Boolean): Boolean = when (val prev = this._prev) {
-        is ListClosedForAll -> false
-        is ListClosedForSome -> allowedAfterPartialClosing && prev.addLast(node, allowedAfterPartialClosing)
+    public fun addLast(node: Node, clearanceLevel: Int): Boolean = when (val prev = this._prev) {
+        is ListClosed -> prev.maxForbidden < clearanceLevel && prev.addLast(node, clearanceLevel)
         else -> {
             node._next = this
             node._prev = prev
@@ -34,12 +33,8 @@ public open class LinkedListNode : DisposableHandle {
         }
     }
 
-    public fun closeForSome() {
-        addLast(ListClosedForSome(), allowedAfterPartialClosing = true)
-    }
-
-    public fun close() {
-        addLast(ListClosedForAll(), allowedAfterPartialClosing = false)
+    public fun close(maxForbidden: Int) {
+        addLast(ListClosed(maxForbidden), maxForbidden)
     }
 
     /*
@@ -64,7 +59,7 @@ public open class LinkedListNode : DisposableHandle {
 
     public fun addOneIfEmpty(node: Node): Boolean {
         if (_next !== this) return false
-        addLast(node, allowedAfterPartialClosing = false)
+        addLast(node, Int.MIN_VALUE)
         return true
     }
 }
@@ -88,6 +83,4 @@ public open class LinkedListHead : LinkedListNode() {
     public final override fun remove(): Nothing = throw UnsupportedOperationException()
 }
 
-private class ListClosedForSome: LinkedListNode()
-
-private class ListClosedForAll: LinkedListNode()
+private class ListClosed(val maxForbidden: Int): LinkedListNode()

kotlinx-coroutines-core/jsAndWasmShared/test/internal/LinkedListTest.kt

@@ -12,13 +12,13 @@ class LinkedListTest {
     fun testSimpleAddLastRemove() {
         val list = LinkedListHead()
         assertContents(list)
-        val n1 = IntNode(1).apply { list.addLast(this, allowedAfterPartialClosing = false) }
+        val n1 = IntNode(1).apply { list.addLast(this, Int.MAX_VALUE) }
         assertContents(list, 1)
-        val n2 = IntNode(2).apply { list.addLast(this, allowedAfterPartialClosing = false) }
+        val n2 = IntNode(2).apply { list.addLast(this, Int.MAX_VALUE) }
         assertContents(list, 1, 2)
-        val n3 = IntNode(3).apply { list.addLast(this, allowedAfterPartialClosing = false) }
+        val n3 = IntNode(3).apply { list.addLast(this, Int.MAX_VALUE) }
         assertContents(list, 1, 2, 3)
-        val n4 = IntNode(4).apply { list.addLast(this, allowedAfterPartialClosing = false) }
+        val n4 = IntNode(4).apply { list.addLast(this, Int.MAX_VALUE) }
         assertContents(list, 1, 2, 3, 4)
         assertTrue(n1.remove())
         assertContents(list, 2, 3, 4)

kotlinx-coroutines-core/jvm/test/internal/LockFreeLinkedListLongStressTest.kt

@@ -1,6 +1,5 @@
 package kotlinx.coroutines.internal
 
-import kotlinx.coroutines.testing.*
 import kotlinx.coroutines.testing.TestBase
 import org.junit.Test
 import java.util.*
@@ -31,7 +30,7 @@ class LockFreeLinkedListLongStressTest : TestBase() {
         for (j in 0 until nAddThreads)
             threads += thread(start = false, name = "adder-$j") {
                 for (i in j until nAdded step nAddThreads) {
-                    list.addLast(IntNode(i), allowedAfterPartialClosing = false)
+                    list.addLast(IntNode(i), Int.MAX_VALUE)
                 }
                 println("${Thread.currentThread().name} completed")
                 workingAdders.decrementAndGet()