is there an idiomatic way to process an infinite sequence in

Question

is there an idiomatic way to process an infinite sequence in parallel

gildor · Answer

Sequences are sequential by definition so there is no way to make them parallel For parallel sequence of events you can use Flow

Andrew Gazelka · Answer

No what I am saying is something along the lines of ` numbers from sequence gt split into subsequeces gt do computation in parallel on each sub sequence `

gildor · Answer

Just split into subsequeces run computation on own thread

Andrew Gazelka · Answer

well I guess what I am asking is if there is an idiomatic way to split the sequence

Andrew Gazelka · Answer

would be cool if there were something like a grouping that could be used for an inf sequence

gildor · Answer

You can use `Sequence chunked` which emits list of required size

gildor · Answer

not exactly subsequence but also sequence is not really needed because anyway you should buffer some amount of items to process

Andrew Gazelka · Answer

buffering seems like it would complicate the code

Andrew Gazelka · Answer

I am simply trying to have integers ` 2 inf `

Andrew Gazelka · Answer

and split and see if the number is prime concurrently

gildor · Answer

One call of `chunked SIZE ` doesn t look complicated

Andrew Gazelka · Answer

ah ok fair

gildor · Answer

but I still think that it s pretty limited solution essentially there is no way to return result it s fire and forget

Andrew Gazelka · Answer

hmmm

gildor · Answer

I believe Flow or any other Reactive framework is much better choice

Andrew Gazelka · Answer

``` private fun primes val threads = 6 val infSequence = generateSequence 2 it + 1 runBlocking for i in 0 until threads launch infSequence filter it threads == i filter isPrime it forEach println it ``` eh

Andrew Gazelka · Answer

yeah probably

gildor · Answer

isPrime always blocking cannot be used in parallerl

gildor · Answer

it will block sequence

Andrew Gazelka · Answer

it is my own implementation

Andrew Gazelka · Answer

even tho probably less efficient I m guessing

gildor · Answer

You already have coroutines why not use flow that gives everything out of the box

gildor · Answer

and much more idiomatic

Andrew Gazelka · Answer

how would you idiomatically do this with a flow

gildor · Answer

just make `isPrime` suspend function that runs on particular dispatcher with target parallelism

Andrew Gazelka · Answer

I am so confused

Andrew Gazelka · Answer

why would `isPrime` be suspending it doesn t need to suspend

gildor · Answer

To run on target dispatcher

gildor · Answer

because it s your bottleneck

Andrew Gazelka · Answer

ah I see I think

gildor · Answer

there are a few ways actually one more is just blocking `isPrime` but you split the list and use flatMapConcat

gildor · Answer

Actually for this particular task with prime number Java s Fork Join framework probably the best solution just because it s optimized for CPU bound tasks and have good job stealing algorithm but to make it performant you have to batch work to threads by splitting sequence by chunks

Dennis Schröder · Answer

Take the time to carefully read this <https kotlinlang org docs reference coroutines flow html> Flow is what you need

gildor · Answer

Honestly not sure that pure Flow will be faster for this use case with prime number ir you launch coroutine per each item with chunked windowed it possible to optimise it much more but those operators are not available in 1 3 yet

Matteo Mirk · Answer

for deeper support try asking also on < C1CFAFJSK|coroutines>