Should I use different 'threads' for different parts of the design? I'd hate to, especially given the fact that all those parts are dynamic in nature. Now, to complicate the design, I want to have I/O tasks that read data from a file/network and feed it into the DAG and send its resulting output to the UI thread. Yet the nodes will have to block on their input queues because data will not be ready in most cases. If I feed enough data into this structure I get a CPU-bound workload with a lot of concurrency (and scalability). Edges are naturally implemented as blocking queues. Now that I have light threads I want to use them to implement all nodes. Each node takes data from all its input edges, processes it and sends to all its output edges. > If you're spawning one million threads, each of which will perform a blocking operation, then you're likely not CPU bound If parallel use-cases that benefit from continuations and/or generators come in high demand, we can address them later. C++ favours the former, while Java, like Go, the latter, partly because Java already has a decent parallelism construct, and partly because we believe that the concurrent use-case delivers more value to more people. If you have only one continuation construct, you must choose whether you want to favour one or the other. I am not aware of any single implementation, or even a single user-facing construct, that gives you the optimal experience both in those situations and in I/O-driven concurrency. This happens in two situations: generators, where there is one producer that can be inlined together with the consumer, and parallel workloads where all the tasks are the same. The overhead can be made to be zero when the tasks are known in advance and can be inlined. For CPU-bound workloads, virtually any overhead that isn't zero can come to dominate in many situations.

It is true that some parallel use-cases are more conveniently expressed with continuations, but more on that below.Ģ. In Java, parallel streams and the low-level ForkJoinTask were made to address parallelism, whereas Loom's virtual threads are designed to tackle concurrency. CPU-bound problems that are not externally driven by I/O events fall under the purview of parallelism (shortening the latency of performing a single task by splitting it into cooperating tasks that employ multiple processing units) rather than concurrency (increasing the throughput of handling multiple competing, largely independent events, using scheduling).

Loom network sleeping