async callback using "tokio" will lead to cpu usage to 100%

[Kimhlo]

code:

fn cmd_topic_handle(&mut self) {
let sub = self
.node
.create_async_subscription::<std_msgs::msg::String, _>(
"/run/cmd",
move |req: std_msgs::msg::String| {
async move {
let _ = tokio::spawn(async move {
logger_info!("receive cmd: {}", &req.data);
})
.await;
}
},
)
.unwrap();
self.topic_subs.push(sub);
}

exec ros2 command:
ros2 topic pub /run/cmd std_msgs/msg/String

use shell command:
top -H -p {pid}
waitting the result:

 PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                            

938271 robot 20 0 1095504 23680 17024 R 99.3 0.1 1:44.65 robot_cmd_exec
938273 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.00 tokio-runtime-w
938274 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.00 tokio-runtime-w
938275 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.00 tokio-runtime-w
938276 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.00 tokio-runtime-w
938277 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.01 tokio-runtime-w
938278 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.02 tokio-runtime-w
938279 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.00 robot_cmd_exec
938280 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.05 robot_cmd_exec
938281 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.01 robot_cmd_exec
938282 robot 20 0 1095504 23680 17024 S 0.0 0.1 0:00.03 robot_cmd_exec

According to actual use measurements, in ROS2-Rust's asynchronous subscription, if "tokio::spawn" is used to asynchronously wait for a task to complete,
when the number of subscription calls reaches a certain threshold (about 130+), it leads to a sudden spike in CPU usage to 100%. Is this an issue with the code library?

[mxgrey]

The "basic executor" provided by rclrs doesn't use tokio, so tokio::spawn isn't going to work out of the box without setting up a tokio runtime. I think CPU usage is going to depend on how you've set up your tokio runtime. Can you share any information on that?

If you need to spawn tasks using tokio---some Rust libraries have functions that can only be run when backed by a tokio runtime, so this might not be avoidable---then it would probably be a good idea to implement a tokio-based executor as an alternative to the basic executor. Then your async subscription callbacks will automatically be spawned as tokio tasks.

If implementing a tokio-based executor is too daunting, another approach you could take is to use a regular (non-async) subscription and just pass it a sender, while its receiver is used in a tokio-spawned task and listening for new subscriptions to come in.

[Kimhlo]

Multi-threaded runtime
#[tokio::main]
async fn main() -> Result<()> {

}

[Kimhlo]

if don't using "await" after tokio::spwan, the CPU usage will not up to 100%, too
just like this

fn cmd_topic_handle2(&mut self) { let sub = self .node .create_subscription::<std_msgs::msg::String, _>( "/run/cmd2", move |req: std_msgs::msg::String| { async_std::task::block_on(async move { let _ = tokio::spawn(async move { logger_info!("receive cmd: {}", &req.data); }); }) }, ) .unwrap(); self.topic_subs.push(sub); }
@mxgrey