线程绑定CPU核的意义：

在多核CPU中合理的调度线程在各个核上运行可以获得更高的性能。在多线程编程中，每个线程处理的任务优先级是不一样的，对于要求实时性比较高的线程或者是主线程，对于这种线程我们可以在创建线程时指定其绑定到某个CPU核上，以后这个核就专门处理该线程。这样可以使得该线程的任务可以得到较快的处理，特别是和用户直接交互的任务，较短的响应时间可以提升用户的体验感。

绑定的过程：

几个重要的宏操作：

一个线程的CPU亲合力掩码用一个cpu_set_t结构体来表示一个CPU集合,下面的几个宏分别对这个掩码集进行操作:

CPU_ZERO() 清空一个集合
CPU_SET()与CPU_CLR()分别对将一个给定的CPU号加到一个集合或者从一个集合中去掉.
CPU_ISSET()检查一个CPU号是否在这个集合中

设置获取线程CPU亲和力状态：

(1)sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数设置线程为pid的这个线程,让它运行在mask所设定的CPU上.如果pid的值为0,则表示指定的是当前线程,使当前线程运行在mask所设定的那些CPU上.第二个参数cpusetsize是mask所指定的数的长度.通常设定为sizeof(cpu_set_t).如果当前pid所指定的线程此时没有运行在mask所指定的任意一个CPU上,则该指定的线程会从其它CPU上迁移到mask的指定的一个CPU上运行.
(2)sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数获得pid所指示的线程的CPU位掩码,并将该掩码返回到mask所指向的结构中.即获得指定pid当前可以运行在哪些CPU上.同样,如果pid的值为0.也表示的是当前进程

简单的实例：

#此代码不完整，只是帮助理解绑定过程
#在创建线程时添加以下代码，可以将该线程绑定到1核

cpu_set_t mask;
#将掩码清零
CPU_ZERO(&mask);
#将1添加到掩码中
CPU_SET(1, &mask);

#将本线程绑定到1核
sched_setaffinity(0, sizeof(cpu_set_t), &mask);

如何查看线程是否运行在指定的核上：

补充：

实际工作中，为了方便查看线程的情况，会在创建线程时将相关信息保存到一个文件中，需要时用cat命令查看， 内容包括创建了哪些线程、线程名称、线程id和pid、绑定的CPU核、优先级、调度方式等。

用top命令查看：

top -d 2：查看线程的运行情况和CPU状态
按’h’ 和 1：在上一句的基础上可以查看更详细的信息。
从文件中得到线程pid和ppid，通过top命令，查看线程在哪个CPU核上运行，验证核绑定的核是否一样。

Linux系统提供API函数sched_setaffinity和sched_getaffinity用于设置或获取线程的可以使用的CPU核。

int sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask);

这个函数中pid表示需要设置或获取绑定信息的线程id（或进程id），如果为0，表示对当前调用的线程进行设置；第2个参数cpusetsize一般设置为sizeof(cpu_set_t)，用以表示第3个参数指向的内存结构对象的大小；第3个参数mask指向类型为cpu_set_t对象的指针，用以设置或获取指定线程可以使用的CPU核列表。Linux提供函数CPU_ZERO、CPU_SET和CPU_ISSET对cpu_set_t类型的对象进行操作，其中CPU_ZERO用于清空cpu_set_t类型对象的内容，CPU_SET用于设置cpu_set_t类型对象，CPU_ISSET用于判断cpu_set_t类型对象与核对应的位是否被设置。下面通过简单的代码示例来说明这两个函数的具体用法。

设置线程绑定代码：

cpu_set_t mask;

int blist[8]={2, 5, 13, 9, 3, 6, 7, 4}; //设置需要绑定的核列表

#pragma omp parallel private(mask)

{

         CPU_ZERO(&mask);

         CPU_SET(blist[omp_get_thread_num()], &mask); //对每个线程设置绑定方案

         sched_setaffinity(0,sizeof(cpu_set_t), &mask);

}

该段代码将paralle region里面的8个线程依次绑定到核2，5，13，9，3，6，7，4。同样可以使用sched_getaffinity函数获取线程的能够使用的核的列表，示例代码如下：

int num_processors = sysconf(_SC_NPROCESSORS_CONF); //获取当前节点核的数目

cpu_set_t get;

int i = 0;

CPU_ZERO(&get);

sched_getaffinity(0, sizeof(cpu_set_t), &get); //获取当前调用线程的可以使用的核

for(i = 0; i < num_processors; i++)

{

         if(CPU_ISSET(i, &get))

         {

                   printf(“The current thread %d bound to core %d\n“, omp_get_thread_num(), i);

         }

}

下面是一个完整的例子

文件bind.c

#include<stdlib.h>

#include<stdio.h>

#include<sys/types.h>

#include<sys/sysinfo.h>

#include<unistd.h>

 

#define __USE_GNU

#include<sched.h>

#include<ctype.h>

#include<string.h>

#include<pthread.h>

#define THREAD_MAX_NUM 100  //1个CPU内的最多进程数

 

int num=0;  //cpu中核数

void* threadFun(void* arg)  //arg  传递线程标号（自己定义）

{

         cpu_set_t mask;  //CPU核的集合

         cpu_set_t get;   //获取在集合中的CPU

         int *a = (int *)arg; 

         printf("the a is:%d\n",*a);  //显示是第几个线程

         CPU_ZERO(&mask);    //置空

         CPU_SET(*a,&mask);   //设置亲和力值

         if (sched_setaffinity(0, sizeof(mask), &mask) == -1)//设置线程CPU亲和力

         {

                   printf("warning: could not set CPU affinity, continuing...\n");

         }

         while (1)

         {

                   CPU_ZERO(&get);

                   if (sched_getaffinity(0, sizeof(get), &get) == -1)//获取线程CPU亲和力

                   {

                            printf("warning: cound not get thread affinity, continuing...\n");

                   }

                   int i;

                   for (i = 0; i < num; i++)

                   {

                            if (CPU_ISSET(i, &get))//判断线程与哪个CPU有亲和力

                            {

                                     printf("this thread %d is running processor : %d\n", i,i);

                            }

                   }

         }

 

         return NULL;

}

 

int main(int argc, char* argv[])

{

         num = sysconf(_SC_NPROCESSORS_CONF);  //获取核数

         pthread_t thread[THREAD_MAX_NUM];

         printf("system has %i processor(s). \n", num);

         int tid[THREAD_MAX_NUM];

         int i;

         for(i=0;i<num;i++)

         {

                   tid[i] = i;  //每个线程必须有个tid[i]

                   pthread_create(&thread[0],NULL,threadFun,(void*)&tid[i]);

         }

         for(i=0; i< num; i++)

         {

                   pthread_join(thread[i],NULL);//等待所有的线程结束，线程为死循环所以CTRL+C结束

         }

         return 0;

}

 

编译命令：gcc bind.c -o bind -lpthread

执行：./bind

输出结果：略

 

特别注意：

#define __USE_GNU不要写成#define _USE_GNU

#include<pthread.h>必须写在#define __USE_GNU之后，否则编译会报错

查看你的线程情况可以在执行时在另一个窗口使用top -H来查看线程的情况，查看各个核上的情况请使用top命令然后按数字“1”来查看。

如何将进程、线程与CPU核进行绑定

本文首发于微信公众号【DeepDriving】，欢迎关注。

概念

CPU绑定指的是在多核CPU的系统中将进程或线程绑定到指定的CPU核上去执行。在Linux中，我们可以利用CPU affinity属性把进程绑定到一个或多个CPU核上。

CPU Affinity是进程的一个属性，这个属性指明了进程调度器能够把这个进程调度到哪些CPU上。该属性要求进程在某个指定的CPU上尽量长时间地运行而不被迁移到其他处理器。

CPU Affinity分为2种：soft affinity和hard affinity。soft affinity只是一个建议，如果不可避免，调度器还是会把进程调度到其它的CPU上去执行；hard affinity则是调度器必须遵守的规则， 2.6以上版本的Linux内核可以让开发人员可以编程实现hard affinity。

使用hard affinity的意义

• 提高CPU缓存命中率

CPU各核之间是不共享缓存的，如果进程频繁地在多个CPU核之间切换，则会使旧CPU核的cache失效，失去了利用CPU缓存的优势。如果进程只在某个CPU上执行，可以避免进程在一个CPU上停止执行，然后在不同的CPU上重新执行时发生的缓存无效而引起的性能成本。

• 适合对时间敏感的应用

在实时性要求高应用中，我们可以把重要的系统进程绑定到指定的CPU上，把应用进程绑定到其余的CPU上。这种做法确保对时间敏感的应用程序可以得到运行，同时可以允许其他应用程序使用其余的计算资源。

如何将进程与CPU核进行绑定

• 系统函数

在Linux中，用结构体cpu_set_t来表示CPU Affinity掩码，同时定义了一系列的宏来用于操作进程的可调度CPU集合：

#define _GNU_SOURCE 
#include <sched.h>
void CPU_ZERO(cpu_set_t *set);
void CPU_SET(int cpu, cpu_set_t *set);
void CPU_CLR(int cpu, cpu_set_t *set);
int CPU_ISSET(int cpu, cpu_set_t *set);
int CPU_COUNT(cpu_set_t *set);

具体的作用如下：

CPU_ZERO()：清除集合的内容，让其不包含任何CPU。
CPU_SET()：添加cpu到集合中。
CPU_CLR()：从集合中移除cpu
CPU_ISSET() ：测试cpu是否在集合中。
CPU_COUNT()：返回集合中包含的CPU数量。

在Linux中，可以使用以下两个函数设置和获取进程的CPU Affinity属性：

#define _GNU_SOURCE 
#include <sched.h>
int sched_setaffinity(pid_t pid, size_t cpusetsize,const cpu_set_t *mask);
int sched_getaffinity(pid_t pid, size_t cpusetsize,cpu_set_t *mask);

另外可以通过下面的函数获知当前进程运行在哪个CPU上：

int sched_getcpu(void);

如果调用成功，该函数返回一个非负的CPU编号值。

• 例程

#define _GNU_SOURCE
#include <sched.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    cpu_set_t set;
    int parentCPU, childCPU;
    int j;
    int cpu_num = -1;
    if (argc != 3) {
        fprintf(stderr, "Usage: %s parent-cpu child-cpu\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    parentCPU = atoi(argv[1]);
    childCPU = atoi(argv[2]);
    CPU_ZERO(&set);
    
    switch (fork()) {
        case -1: { /* Error */
            fprintf(stderr, "fork error\n");
            exit(EXIT_FAILURE);
        }
        case 0: { /* Child */
            CPU_SET(childCPU, &set);
            if (sched_setaffinity(getpid(), sizeof(set), &set) == -1) {
                fprintf(stderr, "child sched_setaffinity error\n");
                exit(EXIT_FAILURE);
            }
            sleep(1);
            if (-1 != (cpu_num = sched_getcpu())) {
                fprintf(stdout, "The child process is running on cpu %d\n", cpu_num);
            }
            exit(EXIT_SUCCESS);
        }
        default: { /* Parent */
            CPU_SET(parentCPU, &set);
            if (sched_setaffinity(getpid(), sizeof(set), &set) == -1) {
                fprintf(stderr, "parent sched_setaffinity error\n");
                exit(EXIT_FAILURE);
            }
            if (-1 != (cpu_num = sched_getcpu())) {
                fprintf(stdout, "The parent process is running on cpu %d\n", cpu_num);
            }
            wait(NULL); /* Wait for child to terminate */
            exit(EXIT_SUCCESS);
        }
    }
}

程序首先用CPU_ZERO清空CPU集合，然后调用fork()函数创建一个子进程，并调用sched_setaffinity()函数给父进程和子进程分别设置CPU Affinity，输入参数parentCPU和childCPU分别指定父进程和子进程运行的CPU号。指定父进程和子进程运行的CPU为1和0，程序输出如下：

# ./affinity_test 1 0
The parent process is running on cpu 1
The child process is running on cpu 0

如何将线程与CPU核进行绑定

• 系统函数

前面介绍了进程与CPU的绑定，那么线程可不可以与CPU绑定呢？当然是可以的。在Linux中，可以使用以下两个函数设置和获取线程的CPU Affinity属性：

#define _GNU_SOURCE 
#include <pthread.h>
int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize, const cpu_set_t *cpuset);
int pthread_getaffinity_np(pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset);

• 例程

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
 
static void *thread_start(void *arg) {
    ......
    struct thread_info *tinfo = arg;
    thread = tinfo->thread_id;
    CPU_ZERO(&cpuset);
    CPU_SET(tinfo->thread_num, &cpuset);
    s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
    if (s != 0) {
        handle_error_en(s, "pthread_setaffinity_np");
    } 
    CPU_ZERO(&cpuset);
    s = pthread_getaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
    if (s != 0) {
        handle_error_en(s, "pthread_getaffinity_np");
    }
    
    for (j = 0; j < cpu_num; j++) {
        if (CPU_ISSET(j, &cpuset)) { //如果当前线程运行在CPU j上，则输出信息
            printf(" thread %d is running on cpu %d\n", tinfo->thread_num, j);
        }
    }
    pthread_exit(NULL);
}
 
int main(int argc, char *argv[])
{
    ......
    cpu_num = sysconf(_SC_NPROCESSORS_CONF); //获取系统的CPU数量
    tinfo = calloc(cpu_num, sizeof(struct thread_info));
    
    if (tinfo == NULL) {
        handle_error_en(0, "calloc");
    }
    
    for (j = 0; j < cpu_num; j++) { //有多少个CPU就创建多少个线程
        tinfo[j].thread_num = j;
        s = pthread_create(&tinfo[j].thread_id, NULL, thread_start, &tinfo[j]);
        if (s != 0) {
            handle_error_en(s, "pthread_create");
        }
    }
    
    for (j = 0; j < cpu_num; j++) {
        s = pthread_join(tinfo[j].thread_id, NULL);
        if (s != 0) {
            handle_error_en(s, "pthread_join");
        }
    }
    ......
}

程序首先获取当前系统的CPU数量cpu_num，然后根据CPU数量的数量创建线程，有多少个CPU就创建多少个线程，每个线程都运行在不同的CPU上。在4核的机器中运行结果如下：

$ ./thread_affinity
 thread 1 is running on cpu 1
 thread 0 is running on cpu 0
 thread 3 is running on cpu 3
 thread 2 is running on cpu 2

用taskset命令实现进程与CPU核的绑定

Linux 的taskset命令用于设置或检索由pid指定的运行进程的CPU Affinity，或者以给定的CPU Affinity属性启动新的进程。CPU Affinity属性用位掩码来表示，其中最低位对应第一逻辑CPU，最后一位与最后一个逻辑CPU对应。检索到的掩码仅反映与物理系统上的CPU相对应的位。如果给出无效的掩码（即当前系统上没有对应的有效的CPU掩码），则返回错误。掩码通常以十六进制形式给出。例如：

0x00000001 表示CPU #0,
0x00000003 表示CPU #0 和 #1,
0x0000000f 表示CPU #0 ~ #3

taskset命令的选项如下：

-a, --all-tasks
设置或检索所有由pid指定的进程的CPU Affinity属性。

-c, --cpu-list numbers
指定处理器的数值列表，而不是位掩码。数字用逗号分隔，可以包括范围。比如：0,5,8-11。

-p, --pid
操作由pid指定的进程，不启动新的进程。

下面以Ubuntu16.04中的taskset命令说明该命令的使用方法：

• 显示进程运行的CPU核

命令：taskset -p 1
结果：pid 1‘s current affinity mask: f
说明：f表示进程1运行在CPU#0~CPU#3上

• 指定进程运行在某个特定的CPU核上

命令：taskset -cp 1,2 7737
结果：pid 7737's current affinity list: 0-3
     pid 7737's new affinity list: 1,2
说明：该操作把进程7737限定在CPU#1~CPU#2上运行。

• 进程启动时指定CPU核

命令：taskset -c 1-2 ./get_affinity
结果：This process is running on cpu 1
     This process is running on cpu 2
说明：get_affinity程序通过sched_getaffinity()函数获取当前进程的CPU Affinity属性并输出提示信息。

总结

本文通过几个简单的例子介绍了Linux环境下进程、线程与CPU的绑定方法，希望对大家有参考意义。

欢迎关注我的公众号【DeepDriving】，我会不定期分享计算机视觉、机器学习、深度学习、无人驾驶等领域的文章。