硬核绑定

作者: 梅_梅 | 来源:发表于2016-05-23 11:34 被阅读221次

    概念

    什么是CPU Affinity?
    Affinity
    是进程的一个属性,这个属性指明了进程调度器能够把这个进程调度到哪些CPU上。在Linux中,我们可以利用CPU affinity 把一个或多个进程绑定到一个或多个CPU上。CPU Affinity分为2种,soft affinity和hard affinity。soft affinity仅是一个建议,如果不可避免,调度器还是会把进程调度到其它的CPU
    上。hard affinity是调度器必须遵守的规则。为什么需要CPU
    绑定?

    • 增加CPU缓存的命中率
      CPU之间是不共享缓存的,如果进程频繁的在各个CPU间进行切换,需要不断的使旧CPU
      的cache失效。如果进程只在某个CPU上执行,则不会出现失效的情况。

    • 增加CPU缓存的命中率
      在多个线程操作的是相同的数据的情况下,如果把这些线程调度到一个处理器上,大大的增加了CPU
      缓存的命中率。但是可能会导致并发性能的降低。如果这些线程是串行的,则没有这个影响。

    • 适合time-sensitive
      应用在real-time或time-sensitive应用中,我们可以把系统进程绑定到某些CPU上,把应用进程绑定到剩余的CPU上。典型的设置是,把应用绑定到某个CPU上,把其它所有的进程绑定到其它的CPU上。

    接口分析

    进程绑定

    进程亲和性的设置和获取主要通过下面两个函数来实现:

    #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。

    //绑定硬核
    unsigned long mask = 7; /* processors 0, 1, and 2 */
    
    unsigned int len = sizeof(mask);
    
    if (sched_setaffinity(0, len, &mask) < 0) 
    
    {
    
        perror("sched_setaffinity");
    
    }
    
    //查询绑定id
    unsigned long mask;
    unsigned int len = sizeof(mask);
    
    if (sched_getaffinity(0, len, &mask) < 0) {
    
        perror("sched_getaffinity");
    
        return -1;
    
        }
    
    printf("my affinity mask is: %08lx\n", mask);
    

    线程绑定

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

    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); 
    //将某个cpu加入cpu集中 
    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?
    即调度器只能把指定的进程调度至指定的CPU。最简单的方法是利用fork()的继承特性,子进程继承父进程的affinity。这种方法无需修改和编译内核代码。init进程是所有进程的祖先,我们可以设置init进程的affinity
    来达到设置所有进程的affinity的目地,然后把我们自己的进程绑定到目地CPU上。这样就到达了在指定CPU
    上只运行指定的的进程的目地。那么,如何修改init
    进程的affinity?我们只需在/etc/rc.d/rc.sysinit或/etc/rc.sysinit中,起始处增加如下两行,rc.sysinit文件是init进程运行的第一个脚本。

    /bin/bind 1 1  #绑定init进程至处理器0
    /bin/bind $$ 1  #绑定当前进程至处理器0
    

    线程绑定

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

    源码展示

    进程绑定

    * bind - simple command-line tool to set CPU
     * affinity of a given task
    
     */
    #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;
    }
    

    相关文章

      网友评论

      本文标题:硬核绑定

      本文链接:https://www.haomeiwen.com/subject/ldearttx.html