Monoio and the thread-per-core model
RuntimeComments
I disagree that the results are identical. Rust's borrow checker handles the memory safety of thread-local state far more rigorously than Seastar's approach, which reduces the runtime debugging overhead.
I wonder if the removal of Send and Sync bounds simplifies the developer experience as much as hoped. Many existing crates in the ecosystem still expect those bounds for their own internal logic.
If those crates still need the bounds, does that mean we're just trading one type of compiler fight for another? How does this actually look when you're trying to pull in a standard database driver?
A significant upside here is the ability to use non-thread-safe types like Rc and RefCell within futures. This allows for more efficient shared state management within a single core, avoiding the overhead of Arc and Mutex entirely.
This feels like a huge win now that io_uring is actually stable across more kernel versions... I wonder how this compares to the recent shifts we've seen in ScyllaDB's architecture... could this become the standard for all Rust storage engines?
The throughput gains are mathematically sound. Avoiding cross-core cache invalidation and atomic increments on every task switch provides a measurable floor for performance increases.
seastar did this years ago in c++ and the results were similar.
Why are we still pretending work-stealing is the only way? Most high-performance apps are essentially just a few loops pinned to cores anyway. Is the compiler's strictness just a security blanket for people who don't understand their own hardware?