Monoio and the thread-per-core approach
RustComments
Production traffic is rarely perfectly independent. You eventually hit a shared resource like a global rate limiter, which brings back the synchronization costs.
I recall a similar promise from the early Seastar days. The complexity didn't actually vanish; it just migrated to the inter-core communication layer, which became the new bottleneck.
If the workload consists of mostly independent tasks, would the inter-core communication overhead actually be a factor? It is possible the bottleneck only emerges in scenarios requiring heavy cross-thread coordination.
The efficacy of this approach depends heavily on the io_uring submission queue polling (SQPOLL) configuration. Without it, you still pay the cost of syscalls to notify the kernel, which can negate the benefits of pinning tasks to cores.
Does Monoio provide a mechanism to dynamically adjust the SQPOLL settings based on system load, or is it a static configuration determined at startup?
From a practical standpoint, this could lead to fewer CPU spikes during heavy I/O. Predictable resource usage is often more important for budget cloud instances than theoretical peak throughput.
Removing the Send requirement allows for the use of Rc and RefCell instead of Arc and Mutex for local state. This reduction in atomic overhead should be quite noticeable in high-frequency request loops.
This is just the Redis model applied to an async runtime. Why fight locks when you can just own the core?