cpu绑定和cpu亲和性

太过爱你忘了你带给我的痛 2022-08-02 05:53 206阅读 0赞

将进程/线程与cpu绑定，最直观的好处就是提高了cpu cache的命中率，从而减少内存访问损耗，提高程序的速度。我觉得在NUMA架构下，这个操作对系统运行速度的提升有较大的意义，而在SMP架构下，这个提升可能就比较小。这主要是因为两者对于cache、总线这些资源的分配使用方式不同造成的，NUMA每个cpu有自己的一套资源体系， SMP中每个核心还是需要共享这些资源的，从这个角度来看，NUMA使用cpu绑定时，每个核心可以更专注地处理一件事情，资源体系被充分使用，减少了同步的损耗。SMP由于一部分资源的共享，在进行了绑定操作后，受到的影响还是很大的。

通过linux提供的几个api， 可以轻松地完成这个优化:

下面是一个实例。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* 
2.   \* @FileName: simple\_affinity.c 
3.   \* @Author: wzj 
4.   \* @Brief:  
5.   \* 1. cpu affinity.  case 
6.   \* 2.在子线程中，会继承绑定的cpu...， 不过在子线程中，可以重新分配。 
7.   \*   
8.   \* @History:  
9.   \*  
10.  \*  
11.  \*  
12.  \* @Date: 2012年04月21日星期六12:56:14 
13.  \*  
14.  \*/   
15.   
16. \#include <stdlib.h>  
17. \#include <stdio.h>  
18. \#include <unistd.h>  
19.   
20. \#define \_\_USE\_GNU       //启用CPU\_ZERO等相关的宏  
21. //\#define \_GNU\_SOURCE  
22. \#include <sched.h>  
23. \#include <pthread.h>            //这个东西原来放在\_\_USE\_GNU宏之前，结果被编译器报错说CPU\_ZERO未定义  
24.   
25. **void**\* new\_test\_thread(**void**\* arg)  
26. \{  
27.     cpu\_set\_t mask;  
28.     **int** i = 0;  
29.     **int** num = sysconf(\_SC\_NPROCESSORS\_CONF);    //获取当前的cpu总数  
30.     pthread\_detach(pthread\_self());  
31.       
32.     CPU\_ZERO(&mask);      
33.     CPU\_SET(1, &mask);      //绑定cpu 1  
34.     **if**(sched\_setaffinity(0, **sizeof**(mask), &mask) == -1)      //0 代表对当前线程/进程进行设置。  
35.     \{  
36.         printf("set affinity failed..");  
37.     \}  
38.     **while**(1)  
39.     \{  
40.         CPU\_ZERO(&mask);  
41.         **if**(sched\_getaffinity(0, **sizeof**(mask), &mask) == -1)   
42.         \{  
43.             printf("get failed..\\n");  
44.         \}  
45.   
46.         **for**(i = 0; i < num; i++)  
47.         \{  
48.             **if**(CPU\_ISSET(i, &mask))  
49.             printf("new thread %d run on processor %d\\n", getpid(), i);  
50.         \}  
51.         **while**(1);  
52.         sleep (1);  
53.     \}  
54. \}      //while(1);      //如果觉得不明显，改成这个，

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void**\* child\_test\_thread(**void**\* arg)  
2.  \{  
3.      cpu\_set\_t mask;  
4.      **int** i = 0;  
5.      **int** num = sysconf(\_SC\_NPROCESSORS\_CONF);  
6.      pthread\_detach(pthread\_self());  
7.        
8.      **while**(1)  
9.      \{  
10.         CPU\_ZERO(&mask);  
11.         **if**(sched\_getaffinity(0, **sizeof**(mask), &mask) == -1)   
12.         \{  
13.             printf("get failed..\\n");  
14.         \}  
15.   
16.         **for**(i = 0; i < num; i++)  
17.         \{  
18.             **if**(CPU\_ISSET(i, &mask))  
19.             printf("child thread %d run on processor %d\\n", getpid(), i);  
20.         \}  
21.         sleep (1);  
22.     \}  
23.   
24. \}  
25.   
26. **int**  
27. main(**int** argc, **char**\* argv\[\])  
28. \{  
29.     **int** num = sysconf(\_SC\_NPROCESSORS\_CONF);  
30.     **int** created\_thread = 0;  
31.     **int** myid;  
32.     **int** i;  
33.     **int** j = 0;  
34.     pthread\_t ptid = 0;  
35.   
36.     cpu\_set\_t mask;  
37.     cpu\_set\_t get;  
38.   
39.     **if**(argc != 2)  
40.     \{  
41.         printf("usage: ./cpu num\\n");  
42.         **return** -1;  
43.     \}  
44.     myid = atoi(argv\[1\]);  
45.     printf("system has %i processor(s).\\n", num);  
46.   
47.     CPU\_ZERO(&mask);  
48.     CPU\_SET(myid, &mask);  
49.     **if**(sched\_setaffinity(0, **sizeof**(mask), &mask) == -1)  
50.     \{  
51.         printf("warning: set CPU affinity failed...");  
52.     \}  
53.   
54.     **int** ret = pthread\_create(&ptid, NULL, new\_test\_thread, NULL);  
55.     **if**(ret)  
56.     \{  
57.         **return** -1;  
58.     \}  
59.     ret = pthread\_create(&ptid, NULL, child\_test\_thread, NULL);  
60.     **if**(ret)  
61.     \{  
62.         **return** -1;  
63.     \}  
64.   
65.   
66.     **while**(1)  
67.     \{  
68.         CPU\_ZERO(&get);  
69.         **if**(sched\_getaffinity(0, **sizeof**(get), &get) == -1)  
70.         \{  
71.             printf("can't get cpu affinity...");  
72.         \}  
73.   
74.         **for**(i = 0; i < num; i++)  
75.         \{  
76.             **if**(CPU\_ISSET(i, &get))  
77.             \{  
78.                 printf("this process %d is runing on procesor:%d\\n", getpid(), i);  
79.             \}  
80.         \}  
81.           
82.         sleep(1);  
83.     \}  
84.     //while(1); //使用这个更明显  
85.     **return** 0;  
86. \}

编译：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  gcc -o cpu simple\_affinity.c -lpthread

执行./cpu \[cpu num / masks\] ，使用top观察cpu使用状况。 使用./cpu 0 时，可以发现，两颗核心使用率都比较高， 使用./cpu 1时，可以发现，1核的压力比较重。

当然还可以对线程进行cpu绑定。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#define \_GNU\_SOURCE  
2.  \#include <pthread.h>  
3.     
4.  **int** pthread\_setaffinity\_np(pthread\_t **thread**, **size\_t** cpusetsize,  
5.                            **const** cpu\_set\_t \*cpuset);  
6.  **int** pthread\_getaffinity\_np(pthread\_t **thread**, **size\_t** cpusetsize,  
7.                            cpu\_set\_t \*cpuset);

这个介绍了使用的时机，比较经典：http://www.ibm.com/developerworks/cn/linux/l-affinity.html

[view plain]: http://blog.csdn.net/joker0910/article/details/7484371#