This is really good. Thank you!<p>I've been studying how to create an asynchronous runtime that works across threads. My goal: neither CPU and IO bound work slow down event loops.<p>How do you write code that elegantly defines a state machine across threads/parallelism/async IO?
How do you efficiently define choreographies between microservices, threads, servers and flows?<p>I've only written two Rust programs but in Rust you presumably you can use Rayon (CPU scheduling) and Tokio (IO scheduling)<p>I wrote about using the LMAX Disruptor ringbuffer pattern between threads.<p><a href="https://github.com/samsquire/ideas4#51-rewrite-synchronous-code-into-lmax-disruptor-thread-pools---event-loops-that-dont-block-on-cpu-usage">https://github.com/samsquire/ideas4#51-rewrite-synchronous-c...</a><p>I am designing a state machine formulation syntax that is thread safe and parallelises effectively. It looks like EBNF syntax or a bash pipeline. Parallel steps go in curly brackets. There is an implied interthread ringbuffer between pipes. It is inspired by prolog, whereby there can be multiple conditions or "facts" before a stateline "fires" and transitions. Transitions always go from left to right but within a stateline (what is between a pipe symbol) can fire in any order. A bit like a countdown latch.<p><pre><code> states = state1 | {state1a state1b state1c} {state2a state2b state2c} | state3
</code></pre>
You can can think of each fact as an "await" but all at the same time.<p><pre><code> initial_state.await = { state1a.await state1b.await state1c.await }.await { state2a.await state2b.await state2c.await } | state3.await
</code></pre>
In io_uring and LMAX Disruptor, you split all IO into two halves: submit and handle. Here is a liburing state machine that can send and receive in parallel.<p><pre><code> accept | { submit_recv! | recv | submit_send } { submit_send! | send | submit_recv }
</code></pre>
I want there to be ring buffers between groups of states. So we have full duplex sending and receiving.<p>Here is a state machine for async/await between threads:<p><pre><code> next_free_thread = 2
task(A) thread(1) assignment(A, 1) = running_on(A, 1) |
paused(A, 1)
running_on(A, 1)
thread(1)
assignment(A, 1)
thread_free(next_free_thread) = fork(A, B)
| send_task_to_thread(B, next_free_thread)
| running_on(B, 2)
paused(B, 1)
running_on(A, 1)
| { yield(B, returnvalue) | paused(B, 2) }
{ await(A, B, returnvalue) | paused(A, 1) }
| send_returnvalue(B, A, returnvalue)</code></pre>