精华内容
下载资源
问答
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...

    如何指定进程运行的CPU

    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程和一堆别的进程挤在一起。”。在文章中提到了Linux下的一个工具,taskset,可以设定单个进程运行的CPU。

    同时,因为最近在看redis的相关资料,redis作为单进程模型的程序,为了充分利用多核CPU,常常在一台server上会启动多个实例。而为了减少切换的开销,有必要为每个实例指定其所运行的CPU。

    下文,将会介绍taskset命令,以及sched_setaffinity系统调用,两者均可以指定进程运行的CPU实例。

    1.taskset

    taskset是LINUX提供的一个命令(ubuntu系统可能需要自行安装,schedutils package)。他可以让某个程序运行在某个(或)某些CPU上。

    以下均以redis-server举例。

    1)显示进程运行的CPU

    命令taskset -p 21184

    显示结果:

    pid 21184's current affinity mask: ffffff

    注:21184是redis-server运行的pid

          显示结果的ffffff实际上是二进制24个低位均为1的bitmask,每一个1对应于1个CPU,表示该进程在24个CPU上运行

    2)指定进程运行在某个特定的CPU上

    命令taskset -pc 3 21184

    显示结果:

    pid 21184's current affinity list: 0-23
    pid 21184's new affinity list: 3

    注:3表示CPU将只会运行在第4个CPU上(从0开始计数)。

    3)进程启动时指定CPU

    命令taskset -c 1 ./redis-server ../redis.conf

     

    结合这上边三个例子,再看下taskset的manual,就比较清楚了。

    OPTIONS
    -p, --pid
    operate on an existing PID and not launch a new task

    -c, --cpu-list
    specify a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7,9-11.

     

    2.sched_setaffinity系统调用

    如下文章部分翻译自:http://www.thinkingparallel.com/2006/08/18/more-information-on-pthread_setaffinity_np-and-sched_setaffinity/

    问题描述

    sched_setaffinity可以将某个进程绑定到一个特定的CPU。你比操作系统更了解自己的程序,为了避免调度器愚蠢的调度你的程序,或是为了在多线程程序中避免缓存失效造成的开销,你可能会希望这样做。如下是sched_setaffinity的例子,其函数手册可以参考(http://www.linuxmanpages.com/man2/sched_getaffinity.2.php):

    复制代码
     1 /* Short test program to test sched_setaffinity
     2 * (which sets the affinity of processes to processors).
     3 * Compile: gcc sched_setaffinity_test.c
     4 *              -o sched_setaffinity_test -lm
     5 * Usage: ./sched_setaffinity_test
     6 *
     7 * Open a "top"-window at the same time and see all the work
     8 * being done on CPU 0 first and after a short wait on CPU 1.
     9 * Repeat with different numbers to make sure, it is not a
    10 * coincidence.
    11 */
    12  
    13 #include <stdio.h>
    14 #include <math.h>
    15 #include <sched.h>
    16  
    17 double waste_time(long n)
    18 {
    19     double res = 0;
    20     long i = 0;
    21     while(i <n * 200000) {
    22         i++;
    23         res += sqrt (i);
    24     }
    25     return res;
    26 }
    27  
    28 int main(int argc, char **argv)
    29 {
    30     unsigned long mask = 1; /* processor 0 */
    31  
    32     /* bind process to processor 0 */
    33     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
    34         perror("sched_setaffinity");
    35     }
    36  
    37     /* waste some time so the work is visible with "top" */
    38     printf ("result: %f\n", waste_time (2000));
    39  
    40     mask = 2; /* process switches to processor 1 now */
    41     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
    42         perror("sched_setaffinity");
    43     }
    44  
    45     /* waste some more time to see the processor switch */
    46     printf ("result: %f\n", waste_time (2000));
    47 }
    复制代码

    根据你CPU的快慢,调整waste_time的参数。然后使用top命令,就可以看到进程在不同CPU之间的切换。(启动top命令后按“1”,可以看到各个CPU的情况)。

     

    父进程和子进程之间会继承对affinity的设置。因此,大胆猜测,taskset实际上是首先执行了sched_setaffinity系统调用,然后fork+exec用户指定的进程。


    展开全文
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
    
    

    如何指定进程运行的CPU

     

    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程和一堆别的进程挤在一起。”。在文章中提到了Linux下的一个工具,taskset,可以设定单个进程运行的CPU。

    同时,因为最近在看redis的相关资料,redis作为单进程模型的程序,为了充分利用多核CPU,常常在一台server上会启动多个实例。而为了减少切换的开销,有必要为每个实例指定其所运行的CPU。

     

    下文,将会介绍taskset命令,以及sched_setaffinity系统调用,两者均可以指定进程运行的CPU实例。

    1.taskset

    taskset是LINUX提供的一个命令(ubuntu系统可能需要自行安装,schedutils package)。他可以让某个程序运行在某个(或)某些CPU上。

    以下均以redis-server举例。

    1)显示进程运行的CPU

    命令taskset -p 21184

    显示结果:

    pid 21184's current affinity mask: ffffff

    注:21184是redis-server运行的pid

          显示结果的ffffff实际上是二进制24个低位均为1的bitmask,每一个1对应于1个CPU,表示该进程在24个CPU上运行

    2)指定进程运行在某个特定的CPU上

    命令taskset -pc 3 21184

    显示结果:

    pid 21184's current affinity list: 0-23
    pid 21184's new affinity list: 3

    注:3表示CPU将只会运行在第4个CPU上(从0开始计数)。

    3)进程启动时指定CPU

    命令taskset -c 1 ./redis-server ../redis.conf

     

    结合这上边三个例子,再看下taskset的manual,就比较清楚了。

    OPTIONS
    -p, --pid
    operate on an existing PID and not launch a new task

    -c, --cpu-list
    specify a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7,9-11.

     

    2.sched_setaffinity系统调用

    如下文章部分翻译自:http://www.thinkingparallel.com/2006/08/18/more-information-on-pthread_setaffinity_np-and-sched_setaffinity/

    问题描述

    sched_setaffinity可以将某个进程绑定到一个特定的CPU。你比操作系统更了解自己的程序,为了避免调度器愚蠢的调度你的程序,或是为了在多线程程序中避免缓存失效造成的开销,你可能会希望这样做。如下是sched_setaffinity的例子,其函数手册可以参考(http://www.linuxmanpages.com/man2/sched_getaffinity.2.php):

    复制代码

    1 /* Short test program to test sched_setaffinity 2 * (which sets the affinity of processes to processors). 3 * Compile: gcc sched_setaffinity_test.c 4 *              -o sched_setaffinity_test -lm 5 * Usage: ./sched_setaffinity_test 6 * 7 * Open a "top"-window at the same time and see all the work 8 * being done on CPU 0 first and after a short wait on CPU 1. 9 * Repeat with different numbers to make sure, it is not a10 * coincidence.11 */12  13 #include <stdio.h>14 #include <math.h>15 #include <sched.h>16  17 double waste_time(long n)18 {19     double res = 0;20     long i = 0;21     while(i <n * 200000) {22         i++;23         res += sqrt (i);24     }25     return res;26 }27  28 int main(int argc, char **argv)29 {30     unsigned long mask = 1; /* processor 0 */31  32     /* bind process to processor 0 */33     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {34         perror("sched_setaffinity");35     }36  37     /* waste some time so the work is visible with "top" */38     printf ("result: %f\n", waste_time (2000));39  40     mask = 2; /* process switches to processor 1 now */41     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {42         perror("sched_setaffinity");43     }44  45     /* waste some more time to see the processor switch */46     printf ("result: %f\n", waste_time (2000));47 }

     

    根据你CPU的快慢,调整waste_time的参数。然后使用top命令,就可以看到进程在不同CPU之间的切换。(启动top命令后按“1”,可以看到各个CPU的情况)。

     

    父进程和子进程之间会继承对affinity的设置。因此,大胆猜测,taskset实际上是首先执行了sched_setaffinity系统调用,然后fork+exec用户指定的进程。

     

    假设业务模型中耗费cpu的分四种类型,(1)网卡中断(2)1个处理网络收发包进程(3)耗费cpu的n个worker进程(4)其他不太耗费cpu的进程

    基于1中的 负载均衡是针对进程数,那么(1)(2)大部分时间会出现在cpu0上,(3)的n个进程会随着调度,平均到其他多个cpu上,(4)里的进程也是随着调度分配到各个cpu上;

    当发生网卡中断的时候,cpu被打断了,处理网卡中断,那么分配到cpu0上的worker进程肯定是运行不了的

    其他cpu上不是太耗费cpu的进程获得cpu时,就算它的时间片很短,它也是要执行的,那么这个时候,你的worker进程还是被影响到了;按照调度逻辑,一种非常恶劣的情况是:(1)(2)(3)的进程全部分配到cpu0上,其他不太耗费cpu的进程数很多,全部分配到cpu1,cpu2,cpu3上。。那么网卡中断发生的时候,你的业务进程就得不到cpu了

    如果从业务的角度来说,worker进程运行越多,肯定业务处理越快,人为的将它捆绑到其他负载低的cpu上,肯定能提高worker进程使用cpu的时间

     

    每个cpu都利用起来了,负载会比不绑定的情况下好很多

    有效果的原因:

    依据《linux内核设计与实现》的42节,人为控制一下cpu的绑定还是有用处地
        linux的SMP负载均衡是基于进程数的,每个cpu都有一个可执行进程队列(为什么不是线程队列呢??),只有当其中一个cpu的可执行队列里进程数比其他cpu队列进程数多25%时,才会将进程移动到另外空闲cpu上,也就是说cpu0上的进程数应该是比其他cpu上多,但是会在25%以内。


    示例程序

    复制代码

    cpu.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>int main(int argc, char* argv[]){ int num = sysconf(_SC_NPROCESSORS_CONF); int created_thread = 0; int myid; int i; int j = 0; cpu_set_t mask; cpu_set_t get; if (argc != 2) { printf("usage : ./cpu num\n"); exit(1); } myid = atoi(argv[1]); printf("system has %i processor(s). \n", num); CPU_ZERO(&mask); CPU_SET(myid, &mask); if (sched_setaffinity(0, sizeof(mask), &mask) == -1) { printf("warning: could not set CPU affinity, continuing...\n"); } while (1) { CPU_ZERO(&get); if (sched_getaffinity(0, sizeof(get), &get) == -1) { printf("warning: cound not get cpu affinity, continuing...\n"); } for (i = 0; i < num; i++) { if (CPU_ISSET(i, &get)) { printf("this process %d is running processor : %d\n",getpid(), i); } } } return 0;}

     


    下面是在两个终端分别执行了./cpu 0 ./cpu 2 后得到的结果. 效果比较明显.

    QUOTE:

    Cpu0 : 5.3%us, 5.3%sy, 0.0%ni, 87.4%id, 0.0%wa, 0.0%hi, 2.0%si, 0.0%st
    Cpu1 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu2 : 5.0%us, 12.2%sy, 0.0%ni, 82.8%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu3 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu4 : 0.0%us, 0.0%sy, 0.0%ni, 99.7%id, 0.3%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu5 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu6 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
    Cpu7 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st

    linux下的进程可以通过sched_setaffinity系统调用设置进程亲和力,限定进程只能在某些特定的CPU上运行。负载均衡必须考虑遵守这个限制(前面也多次提到)。

    迁移线程
    前面说到,在普通进程的load_balance过程中,如果负载不均衡,当前CPU会试图从最繁忙的run_queue中pull几个进程到自己的run_queue来。
    但是如果进程迁移失败呢?当失败达到一定次数的时候,内核会试图让目标CPU主动push几个进程过来,这个过程叫做active_load_balance。这里的“一定次数”也是跟调度域的层次有关的,越低层次,则“一定次数”的值越小,越容易触发active_load_balance。
    这里需要先解释一下,为什么load_balance的过程中迁移进程会失败呢?最繁忙run_queue中的进程,如果符合以下限制,则不能迁移:
    1、进程的CPU亲和力限制了它不能在当前CPU上运行;
    2、进程正在目标CPU上运行(正在运行的进程显然是不能直接迁移的);
    (此外,如果进程在目标CPU上前一次运行的时间距离当前时间很小,那么该进程被cache的数据可能还有很多未被淘汰,则称该进程的cache还是热的。对于cache热的进程,也尽量不要迁移它们。但是在满足触发active_load_balance的条件之前,还是会先试图迁移它们。)
    对于CPU亲和力有限制的进程(限制1),即使active_load_balance被触发,目标CPU也不能把它push过来。所以,实际上,触发active_load_balance的目的是要尝试把当时正在目标CPU上运行的那个进程弄过来(针对限制2)。

    在每个CPU上都会运行一个迁移线程,active_load_balance要做的事情就是唤醒目标CPU上的迁移线程,让它执行active_load_balance的回调函数。在这个回调函数中尝试把原先因为正在运行而未能迁移的那个进程push过来。为什么load_balance的时候不能迁移,active_load_balance的回调函数中就可以了呢?因为这个回调函数是运行在目标CPU的迁移线程上的。一个CPU在同一时刻只能运行一个进程,既然这个迁移线程正在运行,那么期望被迁移的那个进程肯定不是正在被执行的,限制2被打破。

    当然,在active_load_balance被触发,到回调函数在目标CPU上被执行之间,目标CPU上的TASK_RUNNING状态的进程可能发生一些变化,所以回调函数发起迁移的进程未必就只有之前因为限制2而未能被迁移的那一个,可能更多,也可能一个没有。

     

     cpu_set_t mask;

            cpu_set_t get;

            int i;

      

            int num = sysconf(_SC_NPROCESSORS_CONF);

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

            CPU_ZERO(&mask);

            CPU_SET(1, &mask);           //指定运行在哪个CPU上。我们linux机器(Linux version 2.6.32-5-amd64 (Debian 2.6.32-35))4CPU,其编号为0-3

            pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask);

            for (i = 0;; i++) {  //此循环导致CPU占用率为100%

                if (!(i%10000))

                {  

                    std::vector<int> myvector;

                    for (int i = 0; i < 1000;i++)

                    {

                        myvector.push_back(i);

                    }

                }

            }

     

    展开全文
  • linux:如何指定进程运行的CPU

    千次阅读 2014-12-28 01:59:37
    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...

    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程和一堆别的进程挤在一起。”。在文章中提到了Linux下的一个工具,taskset,可以设定单个进程运行的CPU。

    同时,因为最近在看redis的相关资料,redis作为单进程模型的程序,为了充分利用多核CPU,常常在一台server上会启动多个实例。而为了减少切换的开销,有必要为每个实例指定其所运行的CPU。

     

    下文,将会介绍taskset命令,以及sched_setaffinity系统调用,两者均可以指定进程运行的CPU实例。

    1.taskset

    taskset是LINUX提供的一个命令(ubuntu系统可能需要自行安装,schedutils package)。他可以让某个程序运行在某个(或)某些CPU上。

    以下均以redis-server举例。

    1)显示进程运行的CPU

    命令taskset -p 21184

    显示结果:

    pid 21184's current affinity mask: ffffff

    注:21184是redis-server运行的pid

          显示结果的ffffff实际上是二进制24个低位均为1的bitmask,每一个1对应于1个CPU,表示该进程在24个CPU上运行

    2)指定进程运行在某个特定的CPU上

    命令taskset -pc 3 21184

    显示结果:

    pid 21184's current affinity list: 0-23
    pid 21184's new affinity list: 3

    注:3表示CPU将只会运行在第4个CPU上(从0开始计数)。

    3)进程启动时指定CPU

    命令taskset -c 1 ./redis-server ../redis.conf

     

    结合这上边三个例子,再看下taskset的manual,就比较清楚了。

    OPTIONS
    -p, --pid
    operate on an existing PID and not launch a new task

    -c, --cpu-list
    specify a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7,9-11.

     

    2.sched_setaffinity系统调用

    问题描述

    sched_setaffinity可以将某个进程绑定到一个特定的CPU。你比操作系统更了解自己的程序,为了避免调度器愚蠢的调度你的程序,或是为了在多线程程序中避免缓存失效造成的开销,你可能会希望这样做。如下是sched_setaffinity的例子:

    /* Short test program to test sched_setaffinity
    * (which sets the affinity of processes to processors).
    * Compile: gcc sched_setaffinity_test.c
    *              -o sched_setaffinity_test -lm
    * Usage: ./sched_setaffinity_test
    *
    * Open a "top"-window at the same time and see all the work
    * being done on CPU 0 first and after a short wait on CPU 1.
    * Repeat with different numbers to make sure, it is not a
    * coincidence.
    */
     
    #include <stdio.h>
    #include <math.h>
    #include <sched.h>
     
    double waste_time(long n)
    {
        double res = 0;
        long i = 0;
        while(i <n * 200000) {
            i++;
            res += sqrt (i);
        }
        return res;
    }
     
    int main(int argc, char **argv)
    {
        unsigned long mask = 1; /* processor 0 */
     
        /* bind process to processor 0 */
        if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
            perror("sched_setaffinity");
        }
     
        /* waste some time so the work is visible with "top" */
        printf ("result: %f\n", waste_time (2000));
     
        mask = 2; /* process switches to processor 1 now */
        if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
            perror("sched_setaffinity");
        }
     
        /* waste some more time to see the processor switch */
        printf ("result: %f\n", waste_time (2000));
    }

    根据你CPU的快慢,调整waste_time的参数。然后使用top命令,就可以看到进程在不同CPU之间的切换。(启动top命令后按“1”,可以看到各个CPU的情况)。

     

    父进程和子进程之间会继承对affinity的设置。因此,大胆猜测,taskset实际上是首先执行了sched_setaffinity系统调用,然后fork+exec用户指定的进程。

    from:http://www.cnblogs.com/liuhao/archive/2012/06/21/2558069.html



    展开全文
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...

    如何指定进程运行的CPU

    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程和一堆别的进程挤在一起。”。在文章中提到了Linux下的一个工具,taskset,可以设定单个进程运行的CPU。

    同时,因为最近在看redis的相关资料,redis作为单进程模型的程序,为了充分利用多核CPU,常常在一台server上会启动多个实例。而为了减少切换的开销,有必要为每个实例指定其所运行的CPU。

     

    下文,将会介绍taskset命令,以及sched_setaffinity系统调用,两者均可以指定进程运行的CPU实例。

    1.taskset

    taskset是LINUX提供的一个命令(ubuntu系统可能需要自行安装,schedutils package)。他可以让某个程序运行在某个(或)某些CPU上。

    以下均以redis-server举例。

    1)显示进程运行的CPU

    命令taskset -p 21184

    显示结果:

    pid 21184’s current affinity mask: ffffff

    注:21184是redis-server运行的pid

          显示结果的ffffff实际上是二进制24个低位均为1的bitmask,每一个1对应于1个CPU,表示该进程在24个CPU上运行

    2)指定进程运行在某个特定的CPU上

    命令taskset -pc 3 21184

    显示结果:

    pid 21184’s current affinity list: 0-23
    pid 21184’s new affinity list: 3

    注:3表示CPU将只会运行在第4个CPU上(从0开始计数)。

    3)进程启动时指定CPU

    命令taskset -c 1 ./redis-server ../redis.conf

     

    结合这上边三个例子,再看下taskset的manual,就比较清楚了。

    OPTIONS
    -p, –pid
    operate on an existing PID and not launch a new task

    -c, –cpu-list
    specify a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7,9-11.

     

    2.sched_setaffinity系统调用

    如下文章部分翻译自:http://www.thinkingparallel.com/2006/08/18/more-information-on-pthread_setaffinity_np-and-sched_setaffinity/

    问题描述

    sched_setaffinity可以将某个进程绑定到一个特定的CPU。你比操作系统更了解自己的程序,为了避免调度器愚蠢的调度你的程序,或是为了在多线程程序中避免缓存失效造成的开销,你可能会希望这样做。如下是sched_setaffinity的例子,其函数手册可以参考(http://www.linuxmanpages.com/man2/sched_getaffinity.2.php):

    复制代码
     1 /* Short test program to test sched_setaffinity
     2 * (which sets the affinity of processes to processors).
     3 * Compile: gcc sched_setaffinity_test.c
     4 *              -o sched_setaffinity_test -lm
     5 * Usage: ./sched_setaffinity_test
     6 *
     7 * Open a "top"-window at the same time and see all the work
     8 * being done on CPU 0 first and after a short wait on CPU 1.
     9 * Repeat with different numbers to make sure, it is not a
    10 * coincidence.
    11 */
    12  
    13 #include <stdio.h>
    14 #include <math.h>
    15 #include <sched.h>
    16  
    17 double waste_time(long n)
    18 {
    19     double res = 0;
    20     long i = 0;
    21     while(i <n * 200000) {
    22         i++;
    23         res += sqrt (i);
    24     }
    25     return res;
    26 }
    27  
    28 int main(int argc, char **argv)
    29 {
    30     unsigned long mask = 1; /* processor 0 */
    31  
    32     /* bind process to processor 0 */
    33     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
    34         perror("sched_setaffinity");
    35     }
    36  
    37     /* waste some time so the work is visible with "top" */
    38     printf ("result: %f\n", waste_time (2000));
    39  
    40     mask = 2; /* process switches to processor 1 now */
    41     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
    42         perror("sched_setaffinity");
    43     }
    44  
    45     /* waste some more time to see the processor switch */
    46     printf ("result: %f\n", waste_time (2000));
    47 }
    复制代码

    根据你CPU的快慢,调整waste_time的参数。然后使用top命令,就可以看到进程在不同CPU之间的切换。(启动top命令后按“1”,可以看到各个CPU的情况)。

     

    父进程和子进程之间会继承对affinity的设置。因此,大胆猜测,taskset实际上是首先执行了sched_setaffinity系统调用,然后fork+exec用户指定的进程。

    在内核空间中如何实现呢?

    linux4.4内核kernel/sched/core.c文件中也有相应的函数实现类似的功能:

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

    使用示例可参考内核源码:
    vi ./Documentation/ia64/err_inject.txt
    vi ./arch/tile/kernel/smpboot.c +68

    展开全文
  • taskset指定进程执行CPU

    2019-04-08 10:29:26
    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键
  • 为进程指定cpu

    2013-09-28 23:03:36
    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • 指定进程运行的CPU

    2013-06-14 10:42:26
    coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • coolshell最新的文章《性能调优攻略》在“多核CPU调优”章节,提到“我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程...
  • cpu0

    2014-09-18 16:35:12
    CPU多核技术,我们知道,CPU0是很关键的,如果 0 号 CPU 被用得过狠的话,别的 CPU 性能也会下降,因为 CPU0 是有调整功能的,所以,我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们...
  • 并发优化笔记

    2017-11-13 15:48:25
    1. OpenMPOpenMP适用于统一/共享的内存模型(unified/shared memory),比如多核CPU共享同一个内存,各个核心通过内存分享交换数据。 所以OpenMP通常用于多核处理器计算优化。 OpenMP:线程级(并行粒度);共享...
  • Python线程池使用

    千次阅读 2017-04-25 21:20:34
    背景多线程不能利用CPU多核优势,IO密集型可用多线程,CPU密集型适合用多进程。在采用多线程的时候就无需手动根据任务数量来创建线程,而是在建立线程池之后,不断地对线程池中空闲线程进行任务的分配。 使用线程池...
  • SQL优化相关(MS SQL)

    2014-05-20 19:17:00
    1.With T AS () 中语句会单独生成执行计划 2.MS SQL数据库中已“页”的方式按...5.表分区,利用CPU多核特性并行操作数据库 6.数据表数据量较大或join次数较多时时,join方式的自动选择会出现问题,需要在sql中手动...
  • 《CLR via C#(第3版) 》针对.NET Framework 4.0和多核编程进行了全面更新和修订,是帮助读者深入探索和掌握公共语言运行时、C#和.NET开发的重要参考,同时也是帮助开发人员构建任何一种应用程序(如Microsoft ...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

多核cpu手动分配