~ Don't do extra help in conflated channels

* conflatePreviousSendBuffered does not need to help when its own
  node was removed.
* LockFreeLinkedList.helpRemovePrev does not need to look for the next
  non-removed node to ensure progress.

Author: elizarov

kotlinx-coroutines-core/common/src/channels/ConflatedChannel.kt

@@ -4,8 +4,8 @@
 
 package kotlinx.coroutines.channels
 
-import kotlinx.coroutines.selects.*
 import kotlinx.coroutines.internal.*
+import kotlinx.coroutines.selects.*
 
 /**
  * Channel that buffers at most one element and conflates all subsequent `send` and `offer` invocations,
@@ -46,13 +46,14 @@ internal open class ConflatedChannel<E> : AbstractChannel<E>() {
     }
 
     private fun conflatePreviousSendBuffered(node: SendBuffered<E>) {
-        // Conflate all previous SendBuffered, helping other sends to conflate
-        var prev = node.prevNode
+        // Conflate all previous SendBuffered, helping other sends to conflate, but only as long
+        // as this node itself is not removed
+        var prev = node.prevNodeIfNotRemoved ?: return
         while (prev is SendBuffered<*>) {
             if (!prev.remove()) {
                 prev.helpRemove()
             }
-            prev = prev.prevNode
+            prev = prev.prevNodeIfNotRemoved ?: return
         }
     }
 

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

@@ -11,6 +11,7 @@ public expect open class LockFreeLinkedListNode() {
     public val isRemoved: Boolean
     public val nextNode: LockFreeLinkedListNode
     public val prevNode: LockFreeLinkedListNode
+    public val prevNodeIfNotRemoved: LockFreeLinkedListNode?
     public fun addLast(node: LockFreeLinkedListNode)
     public fun addOneIfEmpty(node: LockFreeLinkedListNode): Boolean
     public inline fun addLastIf(node: LockFreeLinkedListNode, crossinline condition: () -> Boolean): Boolean

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

@@ -23,6 +23,7 @@ public open class LinkedListNode {
 
     public inline val nextNode get() = _next
     public inline val prevNode get() = _prev
+    public inline val prevNodeIfNotRemoved: LockFreeLinkedListNode? get() = _prev.takeIf { !_removed }
     public inline val isRemoved get() = _removed
 
     public fun addLast(node: Node) {

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

@@ -108,6 +108,9 @@ public actual open class LockFreeLinkedListNode {
     public actual val prevNode: Node
         get() = correctPrev(null) ?: findPrevNonRemoved(_prev.value)
 
+    public actual val prevNodeIfNotRemoved: LockFreeLinkedListNode?
+        get() = correctPrev(null)
+    
     private tailrec fun findPrevNonRemoved(current: Node): Node {
         if (!current.isRemoved) return current
         return findPrevNonRemoved(current._prev.value)
@@ -258,21 +261,13 @@ public actual open class LockFreeLinkedListNode {
     // Helps with removal of this node
     public actual fun helpRemove() {
         // Note: this node must be already removed
-        (next as Removed).ref.helpRemovePrev()
+        (next as Removed).ref.correctPrev(null)
     }
 
     // Helps with removal of nodes that are previous to this
-    private fun helpRemovePrev() {
-        // We need to call correctPrev on a non-removed node to ensure progress, since correctPrev bails out when
-        // called on a removed node. There's always at least one non-removed node (list head).
-        var node = this
-        while (true) {
-            val next = node.next
-            if (next !is Removed) break
-            node = next.ref
-        }
-        // Found a non-removed node
-        node.correctPrev(null)
+    @PublishedApi
+    internal fun helpRemovePrev() {
+        correctPrev(null)
     }
 
     public actual fun removeFirstOrNull(): Node? {
@@ -309,13 +304,14 @@ public actual open class LockFreeLinkedListNode {
                  * However, we limit the number of attempts to move to the next node and help with removal at the end
                  * to avoid repeatedly scanning very long lists in LinkedListChannel.
                  */
-                if (moveNextAttempts++ < 32) {
+                if (moveNextAttempts++ < 4) {
                     first = next
                 } else {
-                    break // help and start from the beginning
+                    // help and start from the beginning
+                    next.helpRemovePrev()
+                    break
                 }
             }
-            first.helpRemove() // help remove this one and retry from the beginning of the list
         }
     }
 

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

@@ -21,6 +21,7 @@ public open class LinkedListNode {
 
     public inline val nextNode get() = _next
     public inline val prevNode get() = _prev
+    public inline val prevNodeIfNotRemoved: LockFreeLinkedListNode? get() = _prev.takeIf { !_removed }
     public inline val isRemoved get() = _removed
 
     public fun addLast(node: Node) {