首页 > Scheduler > CPU亲和性的使用与机制

CPU亲和性的使用与机制

Scheduler 2013-08-15

CPU的亲和性, 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器,亲和性是从affinity翻译过来的,应该有点不准确,给人的感觉是亲和性就是有倾向的意思,而实际上是倒向的意思,称为CPU关联性更好,程序员的土话就是绑定CPU,绑核。

在多核运行的机器上,每个CPU本身自己会有缓存,缓存着进程使用的信息,而进程可能会被OS调度到其他CPU上,如此,CPU cache命中率就低了,当绑定CPU后,程序就会一直在指定的cpu跑,不会由操作系统调度到其他CPU上,性能有一定的提高。

另外一种使用绑核考虑就是将重要的业务进程隔离开,对于部分实时进程调度优先级高,可以将其绑定到一个指定核上,既可以保证实时进程的调度,也可以避免其他CPU上进程被该实时进程干扰。

1.CPU亲和性在用户态的使用

linux的CPU亲和性在用户态表现为一个cpu_set_t掩码的形式,用户可以调用两个函数设置和获取掩码:

#define _GNU_SOURCE /* See feature_test_macros(7) */
 #include

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

int sched_getaffinity(pid_t pid, size_t cpusetsize,
 cpu_set_t *mask);

sched_setaffinity是设置指定pid亲和性掩码的,mask是传入的参数;sched_getaffinity则是获取指定pid亲和性掩码的,mask是获取的参数。

cpusetsize可以通过sizeof cpu_set_t算出来。

cpu_set_t 是一个掩码数组,一共有1024位,每一位都可以对应一个cpu核心,以下宏,都是对这个掩码进行操作的。如果需要,一个进程是可以绑定多个cpu的。

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

而mask的表现是如此的:如果是0X23,转换成二进制则为00100011,则表明进程绑定在0核、1核和5核上。

绑核需要注意是,子进程会继承父进程的绑核关系。

代码实例:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>

#include <unistd.h>

#include <sched.h>
#include <pthread.h>

#include <sys/syscall.h>

#define gettid() syscall(__NR_gettid)

void *test_thread(void *arg)
{
    cpu_set_t mask;
    int loop = 0;
    int cpu_num = 0;

    cpu_num = sysconf(_SC_NPROCESSORS_CONF);

    pthread_detach(pthread_self());

    CPU_ZERO(&mask);
    CPU_SET(1, &mask);

    if(sched_setaffinity(0, sizeof(mask), &mask) == -1)
    {
        printf("set affinity failedn");
    }

    while(1)
    {
        CPU_ZERO(&mask);

        if(sched_getaffinity(0, sizeof(mask), &mask) == -1)
        {
            printf("get failedn");
        }

        for(loop = 0; loop < cpu_num; loop++)
        {
            if(CPU_ISSET(loop, &mask))
            {
                printf("test thread %lu run on processor %dn",
                        gettid(), loop);
            }
        }

        sleep(1);
    }

}

void *child_thread(void *arg)
{
    cpu_set_t mask;
    int loop = 0;
    int cpu_num = 0;

    cpu_num = sysconf(_SC_NPROCESSORS_CONF);
    pthread_detach(pthread_self());

    while(1)
    {
        CPU_ZERO(&mask);

        if(sched_getaffinity(0, sizeof(mask), &mask) == -1)
        {
            printf("get failedn");
        }

        for(loop = 0; loop < cpu_num; loop++)
        {
            if(CPU_ISSET(loop, &mask))
            {
                printf("child thread %lu run on processor %dn",
                        gettid(), loop);
            }
        }

        sleep(1);

    }
}

int main(int argc, char *argv[])
{
    int cpu_num = 0;
    pthread_t thread;
    int cpuid = 0;
    int ret = 0;
    int loop = 0;

    cpu_set_t mask_set;
    cpu_set_t mask_get;

    if(argc != 2)
    {
        printf("usage:cpu numn");
        return -1;
    }

    cpuid = atoi(argv[1]);

    /* 获取系统CPU的个数 */
    cpu_num = sysconf(_SC_NPROCESSORS_CONF);
    printf("system has %i processor.n", cpu_num);

    /* 初始化mask_set */
    CPU_ZERO(&mask_set);
    CPU_SET(cpuid, &mask_set);

    if(sched_setaffinity(0, sizeof(mask_set), &mask_set) == -1)
    {
        printf("Warning:set cpu %d affinity failedn", cpuid);
    }

    ret = pthread_create(&thread, NULL, child_thread, NULL);
    if(ret)
    {
        printf("Error:pthread_create failedn");
        return -1;
    }

    ret = pthread_create(&thread, NULL, test_thread, NULL);
    if(ret)
    {
        printf("Error:pthread_create failedn");
        return -1;
    }

    while(1)
    {
        CPU_ZERO(&mask_get);
        if(sched_getaffinity(0, sizeof(mask_get), &mask_get) == -1)
        {
            printf("Warning:get cpu %d affinity failedn", cpuid);
        }

        for(loop = 0; loop < cpu_num; loop++)
        {
            if(CPU_ISSET(loop, &mask_get))
            {
                printf("this processor %lu is running on processor:
                        %dn", gettid(), loop);
            }
        }

        sleep(1);
    }

    return 0;
}

执行之后根据打印和/proc stat的内容可以判断,status有

Cpus_allowed: 08
Cpus_allowed_list: 3

可以更清楚的看到进程绑核状态

但是如果进程已经在运行过程中,用户不能直接改动代码,就用taskset工具更改CPU亲和性关系。

taskset [options] -p [mask] pid

其中mask前面已说了,参看man手册更详细一点。

二、CPU亲和性在内核态机制

在内核进程结构体task_struct里面有一个参数,即为

cpumask_t cpus_allowed;

用来记住CPU的绑核关系。

内核尤其是调度的时候,可以保证让task不会被调度到其他CPU上


static inline
int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
{
	int cpu = p->sched_class->select_task_rq(p, sd_flags, wake_flags);

	/*
	 * In order not to call set_task_cpu() on a blocking task we need
	 * to rely on ttwu() to place the task on a valid ->cpus_allowed
	 * cpu.
	 *
	 * Since this is common to all placement strategies, this lives here.
	 *
	 * [ this allows ->select_task() to simply return task_cpu(p) and
	 *   not worry about this generic constraint ]
	 */
	if (unlikely(!cpumask_test_cpu(cpu, &p->cpus_allowed) ||
		     !cpu_online(cpu)))
		cpu = select_fallback_rq(task_cpu(p), p);

	return cpu;
}

进程在选择CPU队列的时候,只选择被允许的CPU队列,使用cpumask_test_cpu进行测试。


CPU亲和性的使用与机制来自于OenHan,链接为:http://oenhan.com/cpu-affinity
更多阅读