文盘Rust -- tokio绑定cpu实践

tokio 是 rust 生态中流行的异步运行时框架。在实际生产中我们如果希望 tokio 应用程序与特定的 cpu core 绑定该怎么处理呢？这次我们来聊聊这个话题。
首先我们先写一段简单的多任务程序。

1. use tokio::runtime;
2. pub fn main() {
3.     let rt = runtime::Builder::new_multi_thread()
4.         .enable_all()
5.         .build()
6.         .unwrap();
8.     rt.block_on(async {
9.         for i in 0..8 {
10.             println!("num {}", i);
11.             tokio::spawn(async move {
12.                 loop {
13.                     let mut sum: i32 = 0;
14.                     for i in 0..100000000 {
15.                         sum = sum.overflowing_add(i).0;
16.                     }
17.                     println!("sum {}", sum);
18.                 }
19.             });
20.         }
21.     });
22. }

复制代码

程序非常简单，首先构造一个tokio runtime 环境，然后派生多个 tokio 并发，每个并发执行一个无限循环做overflowing_add。overflowing_add函数返回一个加法的元组以及一个表示是否会发生算术溢出的布尔值。如果会发生溢出，那么将返回包装好的值。然后取元祖的第一个元素打印。
这个程序运行在 Ubuntu 20 OS，4 core cpu。通过nmon的监控如下：

可以看到每个 core 都有负载。
要想把负载绑定在某一 core 上，需要使用core_affinity_rs。core_affinity_rs是一个用于管理CPU亲和力的Rust crate。目前支持Linux、Mac OSX和Windows。官方宣称支持多平台，本人只做了linux 操作系统的测试。
我们把代码修改一下：

1. use tokio::runtime;
3. pub fn main() {
4.     let core_ids = core_affinity::get_core_ids().unwrap();
5.     println!("core num {}", core_ids.len());
6.     let core_id = core_ids[1];
8.     let rt = runtime::Builder::new_multi_thread()
9.         .on_thread_start(move || {
10.             core_affinity::set_for_current(core_id.clone());
11.         })
12.         .enable_all()
13.         .build()
14.         .unwrap();
16.     rt.block_on(async {
17.         for i in 0..8 {
18.             println!("num {}", i);
19.             tokio::spawn(async move {
20.                 loop {
21.                     let mut sum: i32 = 0;
22.                     for i in 0..100000000 {
23.                         sum = sum.overflowing_add(i).0;
24.                     }
25.                     println!("sum {}", sum);           
26.                 }
27.             });
28.         }
29.     });
30. }

复制代码

在构建多线程runtime时，在on_thread_start 设置cpu亲和。可以看到负载被绑定到了指定的core上。

上面的代码只是把负载绑定到了一个core上，那么要绑定多个核怎么办呢？
我们看看下面的代码

1. pub fn main() {
2.     let core_ids = core_affinity::get_core_ids().unwrap();
3.     println!("core num {}", core_ids.len());
5.     let rt = runtime::Builder::new_multi_thread()
6.         .enable_all()
7.         .build()
8.         .unwrap();
10.     let mut idx = 2;
12.     rt.block_on(async {
13.         for i in 0..8 {
14.             println!("num {}", i);
15.             let core_id = core_ids[idx];
16.             if idx.eq(&(core_ids.len() - 1)) {
17.                 idx = 2;
18.             } else {
19.                 idx += 1;
20.             }
22.             tokio::spawn(async move {
23.                 let res = core_affinity::set_for_current(core_id);
24.                 println!("{}", res);
25.                 loop {
26.                     let mut sum: i32 = 0;
27.                     for i in 0..100000000 {
28.                         sum = sum.overflowing_add(i).0;
29.                     }
30.                     println!("sum {}", sum);
31.                     }
32.             });
33.         }
34.     });
35. }

复制代码

代码需要把所有负载绑在 core3和core4上。原理是在派生任务中加入 core_affinity 设置.通过调整idx，将派生并发平均绑定在指定的core上。代码运行的监控如下图。

本期关于cpu亲和的话题就聊到这儿，下期见

作者：京东科技　贾世闻
来源：京东云开发者社区

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！