Most ROS 2 users write rclcpp::spin(node) and never look inside. The executor is where your callbacks actually get scheduled, and it has historically been a silent bottleneck.
Lyrical Luth ships an executor that demonstrably outperforms the classic ones.
All figures and quotations in this deck come from the referenced blog post.
The layering matters for the rest of the talk: the executor sits in rclcpp, but the new design reaches down into rmw to get notified instead of asking. Entities are the unit of work.
Foreshadow: wait set == polling. Callback groups == the concurrency contract.
This "poll, then service" shape is the root of both problems we will see later.
Note the discovery half is pure overhead - it produces no user-visible work.
Sequential execution is a feature, not only a limitation: it is the reason so much ROS callback code gets away with no locking. Composition into one process / one thread is the standard deployment pattern.
Callback groups were the answer to "how do we parallelize without breaking everyone's implicitly single-threaded callback code?" The contract is opt-in.
The default matters: many users swap in a MultiThreadedExecutor, change nothing else, and get zero parallelism because everything is still in one mutually exclusive group.
This is the "asking" cost. It is paid whether or not there is work to do, and it is paid by the same thread that would otherwise be running your callbacks.
The composition story ("put all your nodes in one process") makes this worse, not better: composition increases the entity count per executor.
So adding threads adds contention on the one step that was never parallelized. Past a point, more threads make throughput worse - which the benchmarks show dramatically.
Push instead of pull. Discovery cost stops scaling with entity count and starts scaling with actual event volume - which is the work you wanted to pay for anyway.
Gap 2 alone disqualifies it for most simulation-driven development workflows.
Gap 3 is a stability problem, not just a performance one.
Promoted out of experimental status by the Client Library WG for the **Lyrical Luth** feature freeze.
The key structural claim: events give you cheap discovery, the scheduler gives you real parallelism, and together they remove both bottlenecks at once - plus sim time support.
"Throughput" = message callbacks actually serviced within the window; latency = callback entry time minus message timestamp. This is a deliberately dense, stressful topology.
Denser workload == more entities == more polling overhead removed. This is the cleanest demonstration of the "discovery is pure overhead" argument.
Read the last bullet slowly: not "slow", but complete starvation of entire subscriptions.
That is the wait_mutex_ contention from Problem 2, at scale.
Low CPU with low throughput means cores sat idle waiting on the lock. The events system
gives the CPU actual callback work to do instead of lock contention.
Be honest about this in the talk: switching executors is not a substitute for fixing a
slow callback or an oversized message. The queue growth is a real failure mode.
The most immediately actionable slide: the reflex of "more threads = faster" is actively
harmful in most ROS 2 nodes, because context switching costs more than the callback.
Thank you - questions welcome. All figures and quotations are from the Polymath Robotics blog post linked above.