CPU 绑定技术

全文转载自 CPU绑定技术，侵删。

概念

什么是CPU Affinity？Affinity 是进程的一个属性，这个属性指明了进程调度器能够把这个进程调度到哪些CPU上。
在Linux中，我们可以利用 CPU affinity 把一个或多个进程绑定到一个或多个CPU上。CPU Affinity分为2种:

soft affinity 仅是一个建议，如果不可避免，调度器还是会把进程调度到其它的CPU上。
hard affinity 是调度器必须遵守的规则。

为什么需要CPU绑定

增加CPU缓存的命中率
CPU之间是不共享缓存的，如果进程频繁的在各个 CPU 间进行切换，需要不断的使旧 CPU 的 cache 失效。如果进程只在某个CPU上执行，则不会出现失效的情况。
适合time-sensitive应用
在 real-time 或 time-sensitive应用中，我们可以把系统进程绑定到某些CPU上，把应用进程绑定到剩余的CPU上。典型的设置是，把应用绑定到某个CPU上，把其它所有的进程绑定到其它的CPU上。

绑定进程和CPU

使用taskset指令

程序内部使用代码

#define _GNU_SOURCE

#include <sched.h>

long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);

long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);

从函数名以及参数名都很明了，唯一需要解释的是第三个参数，这个参数 select 中的 fd_set 比较类似，每个bit代表一个CPU。

设置 affinity 的例子

unsigned long mask = 7; /* processors 0, 1, and 2 */
unsigned int len = sizeof(mask);
if (sched_setaffinity(pid, len, &mask) < 0) 
    perror("sched_setaffinity");

获取 affinity 的例子

unsigned long mask;
unsigned int len = sizeof(mask);
if (sched_getaffinity(pid, len, &mask) < 0) 
{
    perror("sched_getaffinity");
    return -1;
}

printf("my affinity mask is: %08lx\n", mask);

绑定线程和CPU

与进程的情况相似，线程亲和性的设置和获取主要通过下面两个函数来实现：

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);

从函数名以及参数名都很明了，唯一需要点解释下的可能就是cpu_set_t这个结构体了。这个结构体的理解类似于select中的fd_set，可以理解为cpu集，也是通过约定好的宏来进行清除、设置以及判断：

void CPU_ZERO(cpu_set_t *set);   //初始化，设为空   
void CPU_SET(int cpu, cpu_set_t *set);   //将某个cpu加入cpu集中        
void CPU_CLR(int cpu, cpu_set_t *set);   //将某个cpu从cpu集中移出      
int CPU_ISSET(int cpu, const cpu_set_t *set);    //判断某个cpu是否已在cpu集中设置了

进程独占CPU

如何实现一个或多个进程独占一个或多个CPU？即调度器只能把指定的进程调度至指定的CPU。最简单的方法是利用fork()的继承特性，子进程继承父进程的affinity。这种方法无需修改和编译内核代码。
init进程是所有进程的祖先，我们可以设置init进程的affinity来达到设置所有进程的affinity的目地，然后把我们自己的进程绑定到目地CPU上。这样就到达了在指定CPU上只运行指定的的进程的目地。
那么，如何修改init进程的affinity？我们只需在/etc/rc.d/rc.sysinit或/etc/rc.sysinit中，起始处增加如下两行，其中bind是6.1小节编译生成的可执行文件，rc.sysinit文件是init进程运行的第一个脚本。

线程独占CPU

通过内核参数isolcpus 来指示系统保留CPU。然后把目标线程绑定至保留的CPU。

代码测试

绑定进程

#define _GNU_SOURCE
 
#include <stdlib.h>
#include <stdio.h>
#include <sched.h>
 
int main(int argc, char *argv[])
{
    unsigned long new_mask;
    unsigned long cur_mask;
    unsigned int len = sizeof(new_mask);
    pid_t pid;
 
    if (argc != 3) {
   fprintf(stderr,
                "usage: %s [pid] [cpu_mask]\n",
                argv[0]);
   return -1;
    }
 
    pid = atol(argv[1]);
    sscanf(argv[2], "%08lx", &new_mask);
 
    if (sched_getaffinity(pid, len,
                          &cur_mask) < 0) {
   perror("sched_getaffinity");
   return -1;
    }
 
    printf("pid %d's old affinity: %08lx\n",
           pid, cur_mask);
 
    if (sched_setaffinity(pid, len, &new_mask)) {
   perror("sched_setaffinity");
   return -1;
    }
 
    if (sched_getaffinity(pid, len,
                          &cur_mask) < 0) {
   perror("sched_getaffinity");
   return -1;
    }
 
    printf(" pid %d's new affinity: %08lx\n",
           pid, cur_mask);
 
    return 0;
}

绑定线程

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
 
void *myfun(void *arg)
{
    cpu_set_t mask;
    cpu_set_t get;
    char buf[256];
    int i;
    int j;
    int num = sysconf(_SC_NPROCESSORS_CONF);
    printf("system has %d processor(s)\n", num);
 
    for (i = 0; i < num; i++) {
        CPU_ZERO(&mask);
        CPU_SET(i, &mask);
        if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {
            fprintf(stderr, "set thread affinity failed\n");
        }
        CPU_ZERO(&get);
        if (pthread_getaffinity_np(pthread_self(), sizeof(get), &get) < 0) {
            fprintf(stderr, "get thread affinity failed\n");
        }
        for (j = 0; j < num; j++) {
            if (CPU_ISSET(j, &get)) {
                printf("thread %d is running in processor %d\n", (int)pthread_self(), j);
            }
        }
        j = 0;
        while (j++ < 100000000) {
            memset(buf, 0, sizeof(buf));
        }
    }
    pthread_exit(NULL);
}
 
int main(int argc, char *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, (void *)myfun, NULL) != 0) {
        fprintf(stderr, "thread create failed\n");
        return -1;
    }
    pthread_join(tid, NULL);
    return 0;
}

参考
[1] http://www.linuxjournal.com/article/6799?page=0,0
[2] http://blog.chinaunix.net/uid-26739406-id-3181199.html