精华内容
下载资源
问答
  • 2020-12-15 21:50:55

    进程绑定CPU

    本文所讲述内容仅适用于linux环境

    1. CPU亲和性

    CPU亲和性是指进程在某个给定的CPU上长时间运行,尽可能少的迁移到其他处理器的倾向性。linux内核的进程调度器天生就具有这样的特性,它尽可能保证一个进程不在处理器之间频繁的迁移,频繁的迁移意味着会增加CPU缓存miss的概率,增加从主存到CPU缓存的复制时间。

    2.6版本linux内核新增了一个机制,它允许开发人员可以编程实现硬CPU亲和性,即程序可以显示的指定进程在哪个CPU上执行。

    2. CPU亲和性应用场景

    有大量计算

    系统对时间敏感,对性能要求高

    最常见的例子就是nginx,在配置nginx子进程的数量时,一般设置成CPU的核心数,同时通过设置worker_cpu_affinity,将不同的子进程绑定到不同的CPU核上,来增强nginx的响应能力。

    如果你的服务器只有一个核,那么是否绑定也就无所谓了。

    3. python程序如何绑定CPU

    Linux 内核 API 提供了一些方法,让用户可以修改位掩码或查看当前的位掩码:

    sched_set_affinity() (用来修改位掩码)

    sched_get_affinity() (用来查看当前的位掩码)

    python开发人员不需要使用这么底层的API,第三方库psutil就可以完成这些操作

    import psutil

    count = psutil.cpu_count()

    p = psutil.Process()

    cpu_lst = p.cpu_affinity() # [0, 1, 2, 3]

    p.cpu_affinity([0, 1]) # 将进程绑定到0和1这两个cpu核上

    更多相关内容
  • 安卓开发时候,绑定线程/进程到指定cpu 上面.可以直接使用一个gradle项目 直接跑起来看效果 adb shell ps -t -p -c
  • 原标题:一文读懂 | 进程怎么绑定 CPU昨天在群里有朋友问:把进程绑定到某个 CPU 上运行是怎么实现的。首先,我们先来了解下将进程与 CPU 进行绑定的好处。进程绑定 CPU 的好处:在多核 CPU 结构中,每个核心有各自...

    原标题:一文读懂 | 进程怎么绑定 CPU

    昨天在群里有朋友问:把进程绑定到某个 CPU 上运行是怎么实现的。

    首先,我们先来了解下将进程与 CPU 进行绑定的好处。

    进程绑定 CPU 的好处:在多核 CPU 结构中,每个核心有各自的L1、L2缓存,而L3缓存是共用的。如果一个进程在核心间来回切换,各个核心的缓存命中率就会受到影响。相反如果进程不管如何调度,都始终可以在一个核心上执行,那么其数据的L1、L2 缓存的命中率可以显著提高。

    所以,将进程与 CPU 进行绑定可以提高 CPU 缓存的命中率,从而提高性能。而进程与 CPU 绑定被称为: CPU 亲和性 。

    设置进程的 CPU 亲和性

    前面介绍了进程与 CPU 绑定的好处后,现在来介绍一下在 Linux 系统下怎么将进程与 CPU 进行绑定的(也就是设置进程的 CPU 亲和性)。

    Linux 系统提供了一个名为 sched_setaffinity 的系统调用,此系统调用可以设置进程的 CPU 亲和性。我们来看看 sched_setaffinity 系统调用的原型:

    intsched_setaffinity( pid_tpid, size_tcpusetsize, constcpu_set_t*mask);

    下面介绍一下 sched_setaffinity 系统调用各个参数的作用:

    pid :进程ID,也就是要进行绑定 CPU 的进程ID。

    cpusetsize :mask 参数所指向的 CPU 集合的大小。

    mask :与进程进行绑定的 CPU 集合(由于一个进程可以绑定到多个 CPU 上运行)。

    参数 mask 的类型为 cpu_set_t ,而 cpu_set_t 是一个位图,位图的每个位表示一个 CPU,如下图所示:

    7ccdecfc0d2744253582953dfa1f32a0.png

    例如,将 cpu_set_t 的第0位设置为1,表示将进程绑定到 CPU0 上运行,当然我们可以将进程绑定到多个 CPU 上运行。

    我们通过一个例子来介绍怎么通过 sched_setaffinity 系统调用来设置进程的 CPU 亲和性:

    # define_GNU_SOURCE

    # include

    # include

    # include

    # include

    # include

    # include

    intmain( intargc, char**argv)

    {

    cpu_set_tcpuset;

    CPU_ZERO(&cpuset); // 初始化CPU集合,将 cpuset 置为空

    CPU_SET( 2, &cpuset); // 将本进程绑定到 CPU2 上

    // 设置进程的 CPU 亲和性

    if(sched_setaffinity( 0, sizeof(cpuset), &cpuset) == -1) {

    printf( "Set CPU affinity failed, error: %s\n", strerror(errno));

    return-1;

    }

    return0;

    }

    CPU 亲和性实现

    知道怎么设置进程的 CPU 亲和性后,现在我们来分析一下 Linux 内核是怎样实现 CPU 亲和性功能的。

    本文使用的 Linux 内核版本为 2.6.23

    Linux 内核为每个 CPU 定义了一个类型为 struct rq 的 可运行的进程队列 ,也就是说,每个 CPU 都拥有一个独立的可运行进程队列。

    一般来说,CPU 只会从属于自己的可运行进程队列中选择一个进程来运行。也就是说,CPU0 只会从属于 CPU0 的可运行队列中选择一个进程来运行,而绝不会从 CPU1 的可运行队列中获取。

    所以,从上面的信息中可以分析出,要将进程绑定到某个 CPU 上运行,只需要将进程放置到其所属的 可运行进程队列 中即可。

    下面我们来分析一下 sched_setaffinity 系统调用的实现, sched_setaffinity 系统调用的调用链如下:

    sys_sched_setaffinity

    └→ sched_setaffinity

    └→ set_cpus_allowed

    └→ migrate_task

    从上面的调用链可以看出, sched_setaffinity 系统调用最终会调用 migrate_task 函数来完成进程与 CPU 进行绑定的工作,我们来分析一下 migrate_task 函数的实现:

    staticint

    migrate_task(struct task_struct *p, intdest_cpu, struct migration_req *req)

    {

    structrq* rq= task_rq( p);

    // 情况1:

    // 如果进程还没有在任何运行队列中

    // 那么只需要将进程的 cpu 字段设置为 dest_cpu 即可

    if(!p->se.on_rq && !task_running(rq, p)) {

    set_task_cpu(p, dest_cpu);

    return0;

    }

    // 情况2:

    // 如果进程已经在某一个 CPU 的可运行队列中

    // 那么需要将进程从之前的 CPU 可运行队列中迁移到新的 CPU 可运行队列中

    // 这个迁移过程由 migration_thread 内核线程完成

    // 构建进程迁移请求

    init_completion(&req->done);

    req->task = p;

    req->dest_cpu = dest_cpu;

    list_add(&req-> list, &rq->migration_queue);

    return1;

    }

    我们先来介绍一下 migrate_task 函数各个参数的意义:

    p :要设置 CPU 亲和性的进程描述符。

    dest_cpu :绑定的 CPU 编号。

    req :进程迁移请求对象(下面会介绍)。

    所以, migrate_task 函数的作用就是将进程描述符为 p 的进程绑定到编号为 dest_cpu 的目标 CPU 上。

    migrate_task 函数主要分两种情况来将进程绑定到某个 CPU 上:

    情况1:如果进程还没有在任何 CPU 的可运行队列中(不可运行状态),那么只需要将进程描述符的 cpu 字段设置为 dest_cpu 即可。当进程变为可运行时,会根据进程描述符的 cpu 字段来自动放置到对应的 CPU 可运行队列中。

    情况2:如果进程已经在某个 CPU 的可运行队列中,那么需要将进程从之前的 CPU 可运行队列中迁移到新的 CPU 可运行队列中。迁移过程由 migration_thread 内核线程完成, migrate_task 函数只是构建一个进程迁移请求,并通知 migration_thread 内核线程有新的迁移请求需要处理。

    而进程迁移过程由 __migrate_task 函数完成,我们来看看 __migrate_task 函数的实现:

    staticint

    __migrate_task(struct task_struct *p, intsrc_cpu, intdest_cpu)

    {

    structrq* rq_dest, * rq_src;

    intret = 0, on_rq;

    ...

    rq_src = cpu_rq(src_cpu); // 进程所在的原可运行队列

    rq_dest = cpu_rq(dest_cpu); // 进程希望放置的目标可运行队列

    ...

    on_rq = p->se.on_rq; // 进程是否在可运行队列中(可运行状态)

    if(on_rq)

    deactivate_task(rq_src, p, 0); // 把进程从原来的可运行队列中删除

    set_task_cpu(p, dest_cpu);

    if(on_rq) {

    activate_task(rq_dest, p, 0); // 把进程放置到目标可运行队列中

    ...

    }

    ...

    returnret;

    }

    __migrate_task 函数主要完成以下两个工作:

    把进程从原来的可运行队列中删除。

    把进程放置到目标可运行队列中。

    其工作过程如下图所示(将进程从 CPU0 的可运行队列迁移到 CPU3 的可运行队列中):

    3cafd0c564c49106ef2a0d1f2a7296b7.png

    如上图所示,进程原本在 CPU0 的可运行队列中,但由于重新将进程绑定到 CPU3,所以需要将进程从 CPU0 的可运行队列迁移到 CPU3 的可运行中。

    迁移过程首先将进程从 CPU0 的可运行队列中删除,然后再将进程插入到 CPU3 的可运行队列中。

    当 CPU 要运行进程时,首先从它所属的可运行队列中挑选一个进程,并将此进程调度到 CPU 中运行。

    总结

    从上面的分析可知,其实将进程绑定到某个 CPU 只是将进程放置到 CPU 的可运行队列中。

    由于每个 CPU 都有一个可运行队列,所以就有可能会出现 CPU 间可运行队列负载不均衡问题。如 CPU0 可运行队列中的进程比 CPU1 可运行队列多非常多,从而导致 CPU0 的负载非常高,而 CPU1 负载非常低的情况。

    当出现上述情况时,就需要对 CPU 间的可运行队列进行重平衡操作,有兴趣的可以自行阅读源码或参考相关资料。返回搜狐,查看更多

    责任编辑:

    展开全文
  • Linux 中用c++实现线程绑定CPU

    千次阅读 2022-03-07 19:46:25
    嵌入式里面我们会使用到多核的cpu,随着产品芯片性能提升,我们也会有很多功能,以及很多进程产生运行,这个时候我们在任务调度调优的时候,把一些进程绑定到固定cpu运行,下面就来分享一下cpu绑定运行的过程: ...

    前言

    嵌入式里面我们会使用到多核的cpu,随着产品芯片性能提升,我们也会有很多功能,以及很多进程产生运行,这个时候我们在任务调度调优的时候,把一些进程绑定到固定cpu运行,下面就来分享一下cpu绑定运行的过程:

    首先运行的环境需要多核,大家可以按照下面命令进行查询对应设备的cpu数量

    查看cpu有几个核

    使用cat /proc/cpuinfo查看cpu信息,如下两个信息:

    processor,指明第几个cpu处理器
    cpu cores,指明每个处理器的核心数

    基本概念

    cpu亲和性(affinity)

    CPU的亲和性, 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器,也称为CPU关联性;再简单的点的描述就将指定的进程或线程绑定到相应的cpu上;在多核运行的机器上,每个CPU本身自己会有缓存,缓存着进程使用的信息,而进程可能会被OS调度到其他CPU上,如此,CPU cache命中率就低了,当绑定CPU后,程序就会一直在指定的cpu跑,不会由操作系统调度到其他CPU上,性能有一定的提高。

    • 软亲和性(affinity)

    就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器,Linux 内核进程调度器天生就具有被称为 软 CPU 亲和性(affinity) 的特性,这意味着进程通常不会在处理器之间频繁迁移。这种状态正是我们希望的,因为进程迁移的频率小就意味着产生的负载小。

    • 硬亲和性(affinity)

    简单来说就是利用linux内核提供给用户的API,强行将进程或者线程绑定到某一个指定的cpu核运行。

    代码绑定实现

    上面我们使用cat /proc/cpuinfo命令查询了自己设备的CPU,以我为例,我的电脑从0~7一共有8核。

    下面是代码的demo:

    #include <stdio.h>
    #include <unistd.h>
    #include <thread>
    
    void thread_func1()
    {
            cpu_set_t mask;
            CPU_ZERO(&mask);
            CPU_SET(1, &mask); //指定该线程使用的CPU
            if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {
                    perror("pthread_setaffinity_np");
            }
            int count = 0;
            while(1)
            {
                    count ++;
                    sleep(1);
                    printf("fun 1 cnt :%d \n",count);
                    for(int i = 0; i < 8; i++) {
                            if (CPU_ISSET(i, &mask))  //查看cpu i 是否在get 集合当中
                            {
                                    printf("1 this process %d of running processor: %d\n", getpid(), i);
                            }
                    }
            }
    }
    
    void thread_func2()
    {
            int count = 0;
            cpu_set_t mask;
            CPU_ZERO(&mask);
            CPU_SET(5, &mask);
            if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {
                    perror("pthread_setaffinity_np");
            }
            while(1)
            {
                    usleep(1000*1000);
                    count ++;
                    printf("fun 2 cnt :%d \n",count);
                    for(int i = 0; i < 8; i++) {
                     if (CPU_ISSET(i, &mask))  //查看cpu i 是否在get 集合当中
                    {
                           printf("2 this process %d of running processor: %d\n", getpid(), i);
    
                        }
                    }
    
            }
    
    }
    
    int main(int argc, char *argv[])
    {
          int cpus = 0;
    
            cpus = sysconf(_SC_NPROCESSORS_CONF);
    
            printf("cpus: %d\n", cpus); //查看cpu的个数;
    
    
        cpu_set_t mask;
        CPU_ZERO(&mask);
        CPU_SET(7, &mask);
        if (sched_setaffinity(0, sizeof(mask), &mask) < 0) {
            perror("sched_setaffinity");
        }
    
        std::thread t1(thread_func1);
        std::thread t2(thread_func2);
            usleep(1000); /* 让当前的设置有足够时间生效*/
           while(1)
            {
                    /*查看运行在当前进程的cpu*/
                    sleep(1); /* 让当前的设置有足够时间生效*/
                    printf("fun main \n");
                    for(int i = 0; i < cpus; i++) {
    
                            if (CPU_ISSET(i, &mask))  //查看cpu i 是否在get 集合当中
                            {
                                    printf("3 this process %d of running processor: %d\n", getpid(), i);
    
                            }
                    }
            }
    
        
        t1.join();
        t2.join();
    }
    
    

    使用此命令编译:

    g++ test_select_cpu.cpp -pthread --std=c++11

    上面一共运行了三个线程,一个是main 主线程,还有两个是自己定义的thread。

    最重要的设置代码就是下面所示:设置cpu 亲和

    cpu_set_t mask;
    CPU_ZERO(&mask);/* 初始化set集,将set置为空*/
    CPU_SET(5, &mask);/* 将对应的cpu序号加入到集合*/
    if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) /*设置cpu 亲和性(affinity)*/
    { 
        perror("pthread_setaffinity_np");
    }
    

    执行代码 ./a.out

    代码绑定查看

    使用ps -ef | grep a.out 命令查看对应的PID

    使用 top命令查看对应pid的线程详细信息 top -p 54056

    在进入top命令后,继续输入 f

    使用上下 移动高亮到p

    空格 选中

    再按q 退出显示

    输入大写H

    就可以看到对应线程数据了


    最右边就是对应的线程绑定的CPU序号。


    作者:良知犹存,白天努力工作,晚上原创公号号主。公众号内容除了技术还有些人生感悟,一个认真输出内容的职场老司机,也是一个技术之外丰富生活的人,摄影、音乐 and 篮球。关注我,与我一起同行。

                                  ‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧  END  ‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧
    

    推荐阅读

    【1】jetson nano开发使用的基础详细分享

    【2】Linux开发coredump文件分析实战分享

    【3】CPU中的程序是怎么运行起来的 必读

    【4】cartographer环境建立以及建图测试

    【5】设计模式之简单工厂模式、工厂模式、抽象工厂模式的对比

    本公众号全部原创干货已整理成一个目录,回复[ 资源 ]即可获得。

    展开全文
  • 支持超线程的numa架构物理硬件视角,将多个CPU封装在一起,这个封装被称为插槽Socket;Core是socket上独立的硬件单元;通过intel的超线程HT技术进一步提升CPU的处理能力,OS看到的逻辑上的核Processor的数量。每个...

    微信公众号:运维开发故事,作者:夏老师

    支持超线程的numa架构

    物理硬件视角,

    • 将多个CPU封装在一起,这个封装被称为插槽Socket;

    • Core是socket上独立的硬件单元;

    • 通过intel的超线程HT技术进一步提升CPU的处理能力,OS看到的逻辑上的核Processor的数量。

    每个硬件线程都可以按逻辑cpu寻址,因此这个处理器看上去有八块cpu。图片

    对于操作系统的视角:

    • CPU(s):8

    • NUMA node0 CPU(s):0,4

    • NUMA node1 CPU(s):1,5

    • NUMA node2 CPU(s):2,6

    • NUMA node3 CPU(s):3,7

    图片

    操作系统视角.png

    L1缓分成两种,一种是指令缓存,一种是数据缓存。L2缓存和L3缓存不分指令和数据。L1和L2缓存在第一个CPU核中,L3则是所有CPU核心共享的内存。L1、L2、L3的越离CPU近就越小,速度也越快,越离CPU远,速度也越慢。再往后面就是内存,内存的后面就是硬盘。我们来看一些他们的速度:

    • L1 的存取速度:4 个CPU时钟周期

    • L2 的存取速度:11 个CPU时钟周期

    • L3 的存取速度:39 个CPU时钟周期

    • RAM内存的存取速度 :107 个CPU时钟周期

    如果 CPU 所要操作的数据在缓存中,则直接读取,这称为缓存命中。命中缓存会带来很大的性能提升,因此,我们的代码优化目标是提升 CPU 缓存的命中率。图片

    在主流的服务器上,一个 CPU 处理器会有 10 到 20 多个物理核。同时,为了提升服务器的处理能力,服务器上通常还会有多个 CPU 处理器(也称为多 CPU Socket),每个处理器有自己的物理核(包括 L1、L2 缓存),L3 缓存,以及连接的内存,同时,不同处理器间通过总线连接。通过lscpu来看:

    root@ubuntu:~# lscpu
    Architecture:          x86_64
    CPU(s):                32
    Thread(s) per core:    1
    Core(s) per socket:    8
    Socket(s):             4
    L1d cache:             32K
    L1i cache:             32K
    L2 cache:              256K
    L3 cache:              20480K
    NUMA node0 CPU(s):     0-7
    NUMA node1 CPU(s):     8-15
    NUMA node2 CPU(s):     16-23
    NUMA node3 CPU(s):     24-31
    
    

    你可能注意到,三级缓存要比一、二级缓存大许多倍,这是因为当下的 CPU 都是多核心的,每个核心都有自己的一、二级缓存,但三级缓存却是一颗 CPU 上所有核心共享的。图片但是,有个地方需要你注意一下:如果应用程序先在一个 Socket 上运行,并且把数据保存到了内存,然后被调度到另一个 Socket 上运行,此时,应用程序再进行内存访问时,就需要访问之前 Socket 上连接的内存,这种访问属于远端内存访问。和访问 Socket 直接连接的内存相比,远端内存访问会增加应用程序的延迟。

    常用性能监测工具

    Linux系统下,CPU与内存子系统性能调优的常用性能监测工具有top、perf、numactl这3个工具。1) top工具 top工具是最常用的Linux性能监测工具之一。通过top工具可以监视进程和系统整体性能。

    • top 查看系统整体的资源使用情况

    • top后输入1 查看看每一个逻辑核cpu的资源使用情况

    • top -p $PID -H 查看某个进程内所有检查的CPU资源使用情况

    • top后输入F,并选择P选项 查看线程执行过程中是否调度到其他cpu上执行,上下文切换过多时,需要注意。

    2) perf工具 perf工具是非常强大的Linux性能分析工具,可以通过该工具获得进程内的调用情况、资源消耗情况并查找分析热点函数。以CentOS为例,使用如下命令安装perf工具:

    • perf top 查看占用 CPU 时钟最多的函数或者指令,因此可以用来查找热点函数。

    • perf -g record – sleep 1 -p $PID 记录进程在1s内的系统调用。

    • perf -g latency --sort max 查看上一步记录的结果,以调度延迟排序。

    • perf report 查看记录

    3) numactl工具 numactl工具可用于查看当前服务器的NUMA节点配置、状态,可通过该工具将进程绑定到指定CPU核上,由指定CPU核来运行对应进程。以CentOS为例,使用如下命令安装numactl工具:

    • numactl -H 查看当前服务器的NUMA配置。

    • numastat 查看当前的NUMA运行状态。

    优化方法

    1) NUMA优化,减少跨NUMA访问内存 不同NUMA内的CPU核访问同一个位置的内存,性能不同。内存访问延时从高到低为:跨CPU>跨NUMA,不跨CPU>NUMA内。因此在应用程序运行时要尽可能地避免跨NUMA访问内存,这可以通过设置线程的CPU亲和性来实现。常用的修改方式有如下:(1)将设备中断绑定到特定CPU核上。可以通过如下命令绑定:

    echo $cpuNumber > /proc/irq/$irq/smp_affinity_list
     例子:echo 0-4 > /proc/irq/78/smp_affinity_list
          echo 3,8 > /proc/irq/78/smp_affinity_list
    
    

    (2)通过numactl启动程序,如下面的启动命令表示启动程序./mongod,mongo就只能在CPU core 0到core7运行(-C控制)。

    numactl -C 0-7 ./mongod
    
    

    (3)可以使用 taskset 命令把一个程序绑定在一个核上运行。

    taskset -c 0 ./redis-server
    
    

    (4)在C/C++代码中通过sched_setaffinity函数来设置线程亲和性。(5)很多开源软件已经支持在自带的配置文件中修改线程的亲和性,例如Nginx可以修改nginx.conf文件中worker_cpu_affinity参数来设置Nginx线程亲和性。

    2绑核注意事项

    在 CPU 的 NUMA 架构下,对 CPU 核的编号规则,并不是先把一个 CPU Socket 中的所有逻辑核编完,再对下一个 CPU Socket 中的逻辑核编码,而是先给每个 CPU Socket 中每个物理核的第一个逻辑核依次编号,再给每个 CPU Socket 中的物理核的第二个逻辑核依次编号。图片注意的是在多个进程要进行亲和性绑核的,你一定要注意 NUMA 架构下 CPU 核的编号方法,这样才不会绑错核。

    预告

    下一节,我们将聊聊如何通过提L1与L2缓存命中率来提高应用程序性能。

    展开全文
  • Nginx-worker如何绑定CPU内核

    千次阅读 2022-04-05 12:23:35
    Nginx-worker如何绑顶CPU内核,减少切换cpu,更好使用cpu核心缓存, 如何手动绑定何自动绑定cpu内核
  • 线程绑定CPU核详解

    千次阅读 2021-03-04 19:55:19
    线程绑定CPU核的意义: 在多核CPU中合理的调度线程在各个核上运行可以获得更高的性能。在多线程编程中,每个线程处理的任务优先级是不一样的,对于要求实时性比较高的线程或者是主线程,对于这种线程我们可以在创建...
  • 过去几十年,各大公司致力于提高CPU晶体管密度和提高CPU工作频率,使得CPU的性能提升基本符合摩尔定律。但随着工艺不断发展,晶体管密度提升已经接近物理极限,CPU工作频率也由于功耗和发热的制约而无法继续提升。在...
  • REDIS是否需要绑定CPU?

    2021-10-17 17:43:24
    在多核服务器上,绑定CPU可以减少上下文切换,尤其是服务器上还运行有其它应用时,REDIS主线程被调度到其它CPU核上时,这时会使用其它核上的L1、L2缓存,如果有其它应用程序也使用了缓存,这样会降低命中率。...
  • 文章目录 超线程技术 && 逻辑CPU Linux下查看CPU相关信息 为什么要绑定CPU? Linux 关于CPU亲和性 Nginx CPU亲和性 ngx_set_cpu_affinity 仿写一份 taskset命令 超线程技术 && 逻辑CPU 超线程技术(Hyper-Threading)...
  • Linux进程、线程绑定CPU以及独占CPU

    千次阅读 2019-11-01 16:54:49
    在很早之前就了解一项技术:线程绑定cpu。该项技术也应用到各种应用软件,来提高性能。这里把自己做的一个实验记录下来,方便日后查阅。 一、进程绑定cpu 我们通过系统调用sched_setaffinity进行绑定,通过sched_...
  • 线程绑定cpu实现

    2013-10-25 16:48:01
    特定的线程绑定cpu上,提高效率和性能
  • 线程/进程绑定CPU代码

    2019-01-15 10:08:57
    文档:https://blog.csdn.net/a569503963/article/details/86149495
  • C/C++ 多线程编程/ 绑定CPU

    千次阅读 2020-06-06 22:28:13
    Pthread是由POSIX提出的一套通用的线程库,在linux平台下,它被广泛的支持,而windows平台下,却并不被支持,而pthreads-w32为我们提供了解决方案 多线程编程需要包含... 多线程程序也可以在单核CPU上运行,但同...
  • 【Linux 编程】线程绑定 CPU

    千次阅读 2020-01-19 21:55:31
    1. 绑定目的 在 Linux 系统中,线程调度是由内核自主完成的。当系统运行在多核 CPU 上时,线程有可能在不同的 CPU 核上来回切换执行。这不利于 CPU 的缓存,缺页率较高。 以 Intel i5 CPU 为例。在多核 CPU 结构中,...
  • 为什么要给nginx绑定cpu: ​ 默认情况下,Nginx的多个进程有可能跑在某一个CPU或者CPU的某一核心上,导致Nginx进程使用硬件资源不均,此外,在多任务,高并发场景下,进程可能会被系统在CPU的不同核心上调度,使得...
  • 手动命令绑定进程与CPU核心,与代码绑定进程与CPU核心
  • C++多线程,为线程绑定cpu

    千次阅读 2019-06-25 18:40:12
    文章目录1,使用2,函数 ...set_cpu("detector", {0, 1, 2}); 2,函数 void set_cpu(std::string thread_name, std::vector<short> cpu_ids) { int i, cpus = 0; cpu_set_t mask; cpu_set_t get; cpus...
  • 进程绑定CPU核心以提高性能

    千次阅读 2019-11-22 16:52:06
    在Linux系统中,进程的调度切换是由内核自动完成的,在多核CPU上,进程有可能在不同的CPU核上来回切换执行,这对CPU的缓存不是很有利。为什么呢?看一张 Intel i5 CPU 的缓存简单示意图: 在多核CPU结构中,每...
  • 现在的服务器上动不动就是多 CPU 多核、多网卡、多硬盘,如果能让网卡中断独占1个 CPU (core)、磁盘 IO 中断独占1个 CPU 的话将会大大减轻单一 CPU 的负担、提高整体处理效率,本文是关闭中断,直接将
  • 查看linux进程绑定cpu

    2020-07-02 14:23:27
    查看进程使用cpu情况,如果绑定了多个cpu会都显示出来 pidstat -p `pidof 进程名` -t 1 CPU指的是编号,有几个编号就代表占用几个CPU (2)按f键可以选择下面配置选项 P = Last Used Cpu (SMP) (3)Esc 退回到...
  • worker_processes 4; worker_cpu_affinity 0001 0010 0100 1000; 四核心系统,每个cpu绑定到一个work进程的写法,记录备忘。
  • 1,头文件 #include <sched.h> 2,在相应进程中添加如下代码... cpu_set_t mask; CPU_ZERO(&mask); CPU_SET(0, &mask); CPU_SET(1, &mask); sched_setaffinity(getpid(), sizeof(mask), ...
  • c++11 thread 线程绑定CPU方法

    千次阅读 2020-04-29 18:36:51
    通过编程设置CPU亲和性 (1) taskset 命令行工具让我们控制整个进程的CPU亲和性; (2)在Linux上,我们可以使用pthread特定的pthread_setafftinity_np函数。通过设置其亲和性将每个线程固定到单个CPU: code: #in....
  • 假如现有一个可执行文件main.so, 1.不设置CPU绑定: ./main.so 2.设置绑定到0号CPU逻辑核心: taskset -c 0 ./bind_core 3.设置绑定到0,1号CPU逻辑核心 taskset -c 0,1 ./bind_core
  • 进程绑定CPU核和参看CPU信息

    千次阅读 2018-08-16 16:07:04
    一:查看CPU信息命令 $cat /proc/cpuinfo processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 94 model name : Intel(R) Core(TM) i7-6700T CPU @ 2.80GHz stepping : 3 microcode : 0xc2 cp...
  • 在Linux系统中,进程的调度切换是由内核自动完成的,在多核CPU上,进程有可能在不同的CPU核上来回切换执行,这对CPU的缓存不是很有利。为什么呢?先看一张 Intel i5 CPU 的缓存简单示意图: 在多核CPU结构中,每个...
  • 通过 taskset 命令可将某个进程与某个 CPU 核心绑定,使得其仅在与之绑定CPU 核心上运行。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 180,698
精华内容 72,279
关键字:

绑定cpu