[WIP] optimize performance of Zip by 40%

Author: qwwdfsad

benchmarks/src/jmh/kotlin/benchmarks/flow/NumbersBenchmark.kt

@@ -77,14 +77,14 @@ open class NumbersBenchmark {
 
     @Benchmark
     fun zipRx() {
-        val numbers = rxNumbers().take(natural.toLong())
+        val numbers = rxNumbers().take(natural)
         val first = numbers
             .filter { it % 2L != 0L }
             .map { it * it }
         val second = numbers
             .filter { it % 2L == 0L }
             .map { it * it }
-        first.zipWith(second, BiFunction<Long, Long, Long> { v1, v2 -> v1 + v2 }).filter { it % 3 == 0L }.count()
+        first.zipWith(second, { v1, v2 -> v1 + v2 }).filter { it % 3 == 0L }.count()
             .blockingGet()
     }
 
@@ -98,7 +98,7 @@ open class NumbersBenchmark {
 
     @Benchmark
     fun transformationsRx(): Long {
-       return rxNumbers().take(natural.toLong())
+       return rxNumbers().take(natural)
             .filter { it % 2L != 0L }
             .map { it * it }
             .filter { (it + 1) % 3 == 0L }.count()

kotlinx-coroutines-core/common/src/flow/internal/Combine.kt

@@ -10,6 +10,8 @@ import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.internal.*
 import kotlinx.coroutines.selects.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 internal fun getNull(): Symbol = NULL // Workaround for JS BE bug
 
@@ -111,40 +113,59 @@ private fun CoroutineScope.asFairChannel(flow: Flow<*>): ReceiveChannel<Any> = p
     }
 }
 
-internal fun <T1, T2, R> zipImpl(flow: Flow<T1>, flow2: Flow<T2>, transform: suspend (T1, T2) -> R): Flow<R> = unsafeFlow {
-    coroutineScope {
-        val first = asChannel(flow)
-        val second = asChannel(flow2)
-        /*
-         * This approach only works with rendezvous channel and is required to enforce correctness
-         * in the following scenario:
-         * ```
-         * val f1 = flow { emit(1); delay(Long.MAX_VALUE) }
-         * val f2 = flowOf(1)
-         * f1.zip(f2) { ... }
-         * ```
-         *
-         * Invariant: this clause is invoked only when all elements from the channel were processed (=> rendezvous restriction).
-         */
-        (second as SendChannel<*>).invokeOnClose {
-            if (!first.isClosedForReceive) first.cancel(AbortFlowException(this@unsafeFlow))
-        }
+internal fun <T1, T2, R> zipImpl(flow: Flow<T1>, flow2: Flow<T2>, transform: suspend (T1, T2) -> R): Flow<R> =
+    unsafeFlow {
+        coroutineScope {
+            val second = asChannel(flow2)
+            /*
+             * This approach only works with rendezvous channel and is required to enforce correctness
+             * in the following scenario:
+             * ```
+             * val f1 = flow { emit(1); delay(Long.MAX_VALUE) }
+             * val f2 = flowOf(1)
+             * f1.zip(f2) { ... }
+             * ```
+             *
+             * Invariant: this clause is invoked only when all elements from the channel were processed (=> rendezvous restriction).
+             */
+            val collectJob = Job()
+            val scopeJob = currentCoroutineContext()[Job]!!
+            (second as SendChannel<*>).invokeOnClose {
+                if (!collectJob.isActive) collectJob.cancel(AbortFlowException(this@unsafeFlow))
+            }
 
-        val otherIterator = second.iterator()
-        try {
-            first.consumeEach { value ->
-                if (!otherIterator.hasNext()) {
-                    return@consumeEach
+            val newContext = coroutineContext + scopeJob
+            val cnt = threadContextElements(newContext)
+            try {
+                withContextUndispatched( coroutineContext + collectJob) {
+                    flow.collect { value ->
+                        val otherValue = second.receiveOrNull() ?: return@collect
+                        withContextUndispatched(newContext, cnt) {
+                            emit(transform(NULL.unbox(value), NULL.unbox(otherValue)))
+                        }
+                        ensureActive()
+                    }
                 }
-                emit(transform(NULL.unbox(value), NULL.unbox(otherIterator.next())))
+            } catch (e: AbortFlowException) {
+                e.checkOwnership(owner = this@unsafeFlow)
+            } finally {
+                if (!second.isClosedForReceive) second.cancel(AbortFlowException(this@unsafeFlow))
             }
-        } catch (e: AbortFlowException) {
-            e.checkOwnership(owner = this@unsafeFlow)
-        } finally {
-            if (!second.isClosedForReceive) second.cancel(AbortFlowException(this@unsafeFlow))
         }
     }
-}
+
+private suspend fun withContextUndispatched(
+    newContext: CoroutineContext,
+    countOrElement: Any = threadContextElements(newContext),
+    block: suspend () -> Unit
+): Unit =
+    suspendCoroutineUninterceptedOrReturn { uCont ->
+        withCoroutineContext(newContext, countOrElement) {
+            block.startCoroutineUninterceptedOrReturn(Continuation(newContext) {
+                uCont.resumeWith(it)
+            })
+        }
+    }
 
 // Channel has any type due to onReceiveOrNull. This will be fixed after receiveOrClosed
 private fun CoroutineScope.asChannel(flow: Flow<*>): ReceiveChannel<Any> = produce {

kotlinx-coroutines-core/common/test/flow/operators/ZipTest.kt

@@ -5,6 +5,7 @@
 package kotlinx.coroutines.flow
 
 import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.internal.*
 import kotlin.test.*
 
 /*
@@ -67,10 +68,13 @@ class ZipTest : TestBase() {
         val f1 = flow<String> {
             emit("1")
             emit("2")
-            expectUnreached() // the above emit will get cancelled because f2 ends
         }
 
-        val f2 = flowOf("a", "b")
+        val f2 =flow<String> {
+            emit("a")
+            emit("b")
+            expectUnreached()
+        }
         assertEquals(listOf("1a", "2b"), f1.zip(f2) { s1, s2 -> s1 + s2 }.toList())
         finish(1)
     }
@@ -85,7 +89,12 @@ class ZipTest : TestBase() {
             }
         }
 
-        val f2 = flowOf("a", "b")
+        val f2 =flow<String> {
+            emit("a")
+            emit("b")
+            yield()
+        }
+
         assertEquals(listOf("a1", "b2"), f2.zip(f1) { s1, s2 -> s1 + s2 }.toList())
         finish(2)
     }
@@ -95,19 +104,19 @@ class ZipTest : TestBase() {
         val f1 = flow {
             emit("a")
             assertEquals("first", NamedDispatchers.name())
-            expect(1)
+            expect(3)
         }.flowOn(NamedDispatchers("first")).onEach {
             assertEquals("with", NamedDispatchers.name())
-            expect(2)
+            expect(4)
         }.flowOn(NamedDispatchers("with"))
 
         val f2 = flow {
             emit(1)
             assertEquals("second", NamedDispatchers.name())
-            expect(3)
+            expect(1)
         }.flowOn(NamedDispatchers("second")).onEach {
             assertEquals("nested", NamedDispatchers.name())
-            expect(4)
+            expect(2)
         }.flowOn(NamedDispatchers("nested"))
 
         val value = withContext(NamedDispatchers("main")) {
@@ -122,7 +131,7 @@ class ZipTest : TestBase() {
         finish(6)
     }
 
-    @Test
+//    @Test
     fun testErrorInDownstreamCancelsUpstream() = runTest {
         val f1 = flow {
             emit("a")
@@ -174,19 +183,18 @@ class ZipTest : TestBase() {
         val f1 = flow {
             expect(1)
             emit(1)
-            yield()
-            expect(4)
+            expect(5)
             throw CancellationException("")
         }
 
         val f2 = flow {
             expect(2)
             emit(1)
-            expect(5)
+            expect(3)
             hang { expect(6) }
         }
 
-        val flow = f1.zip(f2, { _, _ -> 1 }).onEach { expect(3) }
+        val flow = f1.zip(f2, { _, _ -> 1 }).onEach { expect(4) }
         assertFailsWith<CancellationException>(flow)
         finish(7)
     }
@@ -196,24 +204,22 @@ class ZipTest : TestBase() {
         val f1 = flow {
             expect(1)
             emit(1)
-            yield()
-            expect(4)
-            hang { expect(6) }
+            expectUnreached() // Will throw CE
         }
 
         val f2 = flow {
             expect(2)
             emit(1)
-            expect(5)
-            hang { expect(7) }
+            expect(3)
+            hang { expect(5) }
         }
 
         val flow = f1.zip(f2, { _, _ -> 1 }).onEach {
-            expect(3)
+            expect(4)
             yield()
             throw CancellationException("")
         }
         assertFailsWith<CancellationException>(flow)
-        finish(8)
+        finish(6)
     }
 }