如何将所有的进程运行在一个指定的CPU上
2016-06-22 17:11
507 查看
转载：http://blog.csdn.net/sunvince/article/details/6533016
这是CU上的一个问题...
from: http://bbs.chinaunix.net/viewthread.php?tid=2330394
在SMP上，想把所有的用户 态进程运行在一个CPU上，腾出其它CPU干其它事。Linux能通过简单的配置实现吗？而不是去修改内核代码。
回复:
Linux 内核 API 提供了一些方法，让用户可以修改位掩码或查看当前的位掩码：
sched_set_affinity() （用来修改位掩码）
sched_get_affinity() （用来查看当前的位掩码）
回复:
不改内核的话，直接用 taskset 命令就可以啦，兄弟。
不过我喜欢直接在内核里面修改 sched_set_affinity，这样用户空间就省事了。
下面转载... taskset使用方法
from: http://www.blogkid.net/archives/2670.html
我的Linode 十分繁忙，在跑一些密集操作数据库的Rake任务时尤其如此。但我观察发现，Linode服务器的4核CPU，只有第1个核心（CPU#0）非常忙，其他都处于idle状态。
不了解Linux是如何调度的，但目前显然有优化的余地。除了处理正常任务，CPU#0还需要处理每秒 网卡中断。因此，若能将CPU#0分担的任务摊派到其他CPU核心上，可以预见，系统的处理能力将有更大的提升。
两个名词
SMP (Symmetrical Multi-Processing)：指在一个计算机上汇集了一组处理器(多CPU)，各CPU之间共享内存子系统以及总线结构。 [更多... ]
CPU affinity ：中文唤作“CPU亲和力”，是指在CMP架构下，能够将一个或多个进程绑定到一个或多个处理器上运行。[更多... ]
一、在Linux上修改进程的“CPU亲和力”
在Linux上，可以通过 taskset 命令进行修改。以Ubuntu为例，运行如下命令可以安装taskset 工具。
对运行中的进程，文档上说可以用下面的命令，把CPU#1 #2 #3分配给PID为2345的进程：
但我尝试没奏效 ，于是我关掉了MySQL，并用taskset将它启动：
对于其他进程，也可如此处理（nginx除外，详见下文）。之后用top查看CPU的使用情况，原来空闲的#1 #2 #3，已经在辛勤工作了。
二、配置nginx绑定CPU
刚才说nginx除外，是因为nginx提供了更精确的控制。
在conf/nginx.conf 中，有如下一行：
这是用来配置nginx启动几个工作进程的，默认为1。而nginx还支持一个名为worker_cpu_affinity的配置项，也就是说，nginx可以为每个工作进程绑定CPU 。我做了如下配置：
这里0010 0100 1000是掩码，分别代表第2、3、4颗cpu核心。
重启nginx后，3个工作进程就可以各自用各自的CPU了。
三、刨根问底
如果自己写代码，要把进程绑定到CPU，该怎么做？可以用sched_setaffinity 函数。在Linux上，这会触发一次系统调用 。
如果父进程设置了affinity，之后其创建的子进程是否会有同样的属性？我发现子进程确实继承了父进程的affinity属性。
四、Windows？
在Windows上修改“CPU亲和力”，可以通过任务管理器搞定。
* 个人感觉，Windows系统中翻译的“处理器关系”比“CPU亲和力”容易理解点儿
—————–
进行了这样的修改后，即使系统负载达到3以上，不带缓存打开blogkid.net首页（有40多次查询）依然顺畅；以前一旦负载超过了1.5，响应就很慢了。效果很明显。
另外还有一篇文章:详细的用程序例子分析了CPU affinity (亲和力)
from:http://fuzhong1983.blog.163.com/blog/static/16847052009112413613231/
觉得人为控制一下cpu的绑定还是有用处的
1、linux的SMP负载均衡是基于进程数的，每个cpu都有一个可执行进程队列，只有当其中一个cpu的可执行队列里进程数比其他cpu队列进程数多25%时，才会将进程移动到另外空闲cpu上，也就是说cpu0上的进程数应该是比其他cpu上多，但是会在25%以内
2、我们的业务中耗费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的趋势越来越大了. 有时候为了更好地操作机器, 需要将某个进程绑定到具体的CPU上去. 下面给出了一个进程绑定到具体的CPU上去的一个例子.
view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#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;
}
#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
///////////////////////////////////////////////
CPU Affinity (CPU亲合力)
CPU亲合力就是指在Linux系统中能够将一个或多个进程绑定到一个或多个处理器上运行.
一个进程的CPU亲合力掩码决定了该进程将在哪个或哪几个CPU上运行.在一个多处理器系统中,设置CPU亲合力的掩码可能会获得更好的性能.
一个CPU的亲合力掩码用一个cpu_set_t结构体来表示一个CPU集合,下面的几个宏分别对这个掩码集进行操作:
CPU_ZERO() 清空一个集合
CPU_SET()与CPU_CLR()分别对将一个给定的CPU号加到一个集合或者从一个集合中去掉.
CPU_ISSET()检查一个CPU号是否在这个集合中.
其实这几个的用法与select()函数那几个调用差不多.
下面两个函数就是最主要的了:
sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数设置进程为pid的这个进程,让它运行在mask所设定的CPU上.如果pid的值为0,则表示指定的是当前进程,使当前进程运行在mask所设定的那些CPU上.第二个参数cpusetsize是
mask所指定的数的长度.通常设定为sizeof(cpu_set_t).如果当前pid所指定的CPU此时没有运行在mask所指定的任意一个CPU上,则该指定的进程会从其它CPU上迁移到mask的指定的
一个CPU上运行.
sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中.即获得指定pid当前可以运行在哪些CPU上.同样,如果pid的值为0.也表示的是当前进程.
这几个宏与函数的具体用法前面已经有讲解.
关于cpu_set_t的定义
# define __CPU_SETSIZE 1024
# define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
# define __CPUELT(cpu) ((cpu) / __NCPUBITS)
# define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
typedef struct
{
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
# define __CPU_ZERO(cpusetp) /
do { /
unsigned int __i; /
cpu_set_t *__arr = (cpusetp); /
for (__i = 0; __i < sizeof (cpu_set_t) / sizeof (__cpu_mask); ++__i) /
__arr->__bits[__i] = 0; /
} while (0)
# define __CPU_SET(cpu, cpusetp) /
((cpusetp)->__bits[__CPUELT (cpu)] |= __CPUMASK (cpu))
# define __CPU_CLR(cpu, cpusetp) /
((cpusetp)->__bits[__CPUELT (cpu)] &= ~__CPUMASK (cpu))
# define __CPU_ISSET(cpu, cpusetp) /
(((cpusetp)->__bits[__CPUELT (cpu)] & __CPUMASK (cpu)) != 0)
在我的机器上sizeof(cpu_set_t)的大小为128,即一共有1024位.第一位代表一个CPU号.某一位为1则表示某进程可以运行在该位所代表的cpu上.例如
CPU_SET(1, &mask);
则mask所对应的第2位被设置为1.
此时如果printf("%d/n", mask.__bits[0]);就打印出2.表示第2位被置为1了.
具体我是参考man sched_setaffinity文档中的函数的.
然后再参考了一下IBM的 developerWorks上的一个讲解.
http://www.ibm.com/developerworks/cn/linux/l-affinity.html
其中的概念：
分类： Linux基础编程2012-05-22
19:24 949人阅读 评论(0) 收藏 举报
简单地说，CPU 亲和性（affinity） 就是进程要在某个给定的 CPU 上尽量长时间地运行而不被迁移到其他处理器的倾向性。Linux 内核进程调度器天生就具有被称为 软 CPU 亲和性（affinity） 的特性，这意味着进程通常不会在处理器之间频繁迁移。这种状态正是我们希望的，因为进程迁移的频率小就意味着产生的负载小。
2.6 版本的 Linux 内核还包含了一种机制，它让开发人员可以编程实现 硬 CPU 亲和性（affinity）。这意味着应用程序可以显式地指定进程在哪个（或哪些）处理器上运行。
什么是 Linux 内核硬亲和性（affinity）？
在 Linux 内核中，所有的进程都有一个相关的数据结构，称为
如果为给定的进程设置了给定的位，那么这个进程就可以在相关的 CPU 上运行。因此，如果一个进程可以在任何 CPU 上运行，并且能够根据需要在处理器之间进行迁移，那么位掩码就全是 1。实际上，这就是 Linux 中进程的缺省状态。
Linux 内核 API 提供了一些方法，让用户可以修改位掩码或查看当前的位掩码：
注意，
为什么应该使用硬亲和性（affinity）？
通常 Linux 内核都可以很好地对进程进行调度，在应该运行的地方运行进程（这就是说，在可用的处理器上运行并获得很好的整体性能）。内核包含了一些用来检测 CPU 之间任务负载迁移的算法，可以启用进程迁移来降低繁忙的处理器的压力。
一般情况下，在应用程序中只需使用缺省的调度器行为。然而，您可能会希望修改这些缺省行为以实现性能的优化。让我们来看一下使用硬亲和性（affinity） 的 3 个原因。
原因 1. 有大量计算要做
基于大量计算的情形通常出现在科学和理论计算中，但是通用领域的计算也可能出现这种情况。一个常见的标志是您发现自己的应用程序要在多处理器的机器上花费大量的计算时间。
原因 2. 您在测试复杂的应用程序
测试复杂软件是我们对内核的亲和性（affinity）技术感兴趣的另外一个原因。考虑一个需要进行线性可伸缩性测试的应用程序。有些产品声明可以在 使用更多硬件 时执行得更好。
我们不用购买多台机器（为每种处理器配置都购买一台机器），而是可以：
购买一台多处理器的机器
不断增加分配的处理器
测量每秒的事务数
评估结果的可伸缩性
如果应用程序随着 CPU 的增加可以线性地伸缩，那么每秒事务数和 CPU 个数之间应该会是线性的关系（例如斜线图 —— 请参阅下一节的内容）。这样建模可以确定应用程序是否可以有效地使用底层硬件。
其中
Amdahl 法则说明这种加速比在现实中可能并不会发生，但是可以非常接近于该值。对于通常情况来说，我们可以推论出每个程序都有一些串行的组件。随着问题集不断变大，串行组件最终会在优化解决方案时间方面达到一个上限。
Amdahl 法则在希望保持高 CPU 缓存命中率时尤其重要。如果一个给定的进程迁移到其他地方去了，那么它就失去了利用 CPU 缓存的优势。实际上，如果正在使用的 CPU 需要为自己缓存一些特殊的数据，那么所有其他 CPU 都会使这些数据在自己的缓存中失效。
因此，如果有多个线程都需要相同的数据，那么将这些线程绑定到一个特定的 CPU 上是非常有意义的，这样就确保它们可以访问相同的缓存数据（或者至少可以提高缓存的命中率）。否则，这些线程可能会在不同的 CPU 上执行，这样会频繁地使其他缓存项失效。
原因 3. 您正在运行时间敏感的、决定性的进程
我们对 CPU 亲和性（affinity）感兴趣的最后一个原因是实时（对时间敏感的）进程。例如，您可能会希望使用硬亲和性（affinity）来指定一个 8 路主机上的某个处理器，而同时允许其他 7 个处理器处理所有普通的系统调度。这种做法确保长时间运行、对时间敏感的应用程序可以得到运行，同时可以允许其他应用程序独占其余的计算资源。
下面的样例应用程序显示了这是如何工作的。
如何利用硬亲和性（affinity）
现在让我们来设计一个程序，它可以让 Linux 系统非常繁忙。可以使用前面介绍的系统调用和另外一些用来说明系统中有多少处理器的 API 来构建这个应用程序。实际上，我们的目标是编写这样一个程序：它可以让系统中的每个处理器都繁忙几秒钟。
清单 1. 让处理器繁忙
正如您可以看到的一样，这段代码只是通过 fork 调用简单地创建一组线程。每个线程都执行这个方法中后面的代码。现在我们让每个线程都将亲和性（affinity）设置为自己的 CPU。
清单 2. 为每个线程设置 CPU 亲和性（affinity）
如果程序可以执行到这儿，那么我们的线程就已经设置了自己的亲和性（affinity）。调用
亲和性（affinity）掩码是使用在
每个设置的位都对应一个可以合法调度的 CPU，而未设置的位则对应一个不可调度的 CPU。换而言之，进程都被绑定了，只能在那些对应位被设置了的处理器上运行。通常，掩码中的所有位都被置位了。这些线程的亲和性（affinity）都会传递给从它们派生的子进程中。
注意不应该直接修改位掩码。应该使用下面的宏。虽然在我们的例子中并没有全部使用这些宏，但是在本文中还是详细列出了这些宏，您在自己的程序中可能需要这些宏。
清单 3. 间接修改位掩码的宏
对于本文来说，样例代码会继续让每个线程都执行某些计算量较大的操作。
清单 4. 每个线程都执行一个计算敏感的操作
现在您已经了解了在 Linux 2.6 版本的内核中设置 CPU 亲和性（affinity）的基本知识。接下来，我们使用一个
这个方法让程序能够自己确定要让多少个处理器保持繁忙，例如缺省让所有的处理器都处于繁忙状态，并允许用户指定系统中实际处理器范围的一个子集。
运行样例程序
当运行前面介绍的样例程序时，可以使用很多工具来查看 CPU 是否是繁忙的。如果只是简单地进行测试，可以使用 Linux 命令
结束语
这个样例程序虽然非常简单，但是它却展示了使用 Linux 内核中实现的硬亲和性（affinity）的基本知识。（任何使用这段代码的应用程序都无疑会做一些更有意义的事情。）了解了 CPU 亲和性（affinity）内核 API 的基本知识，您就可以从复杂的应用程序中榨取出最后一点儿性能了。
这是CU上的一个问题...
from: http://bbs.chinaunix.net/viewthread.php?tid=2330394
在SMP上，想把所有的用户 态进程运行在一个CPU上，腾出其它CPU干其它事。Linux能通过简单的配置实现吗？而不是去修改内核代码。
回复:
Linux 内核 API 提供了一些方法，让用户可以修改位掩码或查看当前的位掩码：
sched_set_affinity() （用来修改位掩码）
sched_get_affinity() （用来查看当前的位掩码）
回复:
不改内核的话，直接用 taskset 命令就可以啦，兄弟。
不过我喜欢直接在内核里面修改 sched_set_affinity，这样用户空间就省事了。
下面转载... taskset使用方法
from: http://www.blogkid.net/archives/2670.html
我的Linode 十分繁忙，在跑一些密集操作数据库的Rake任务时尤其如此。但我观察发现，Linode服务器的4核CPU，只有第1个核心（CPU#0）非常忙，其他都处于idle状态。
不了解Linux是如何调度的，但目前显然有优化的余地。除了处理正常任务，CPU#0还需要处理每秒 网卡中断。因此，若能将CPU#0分担的任务摊派到其他CPU核心上，可以预见，系统的处理能力将有更大的提升。
两个名词
SMP (Symmetrical Multi-Processing)：指在一个计算机上汇集了一组处理器(多CPU)，各CPU之间共享内存子系统以及总线结构。 [更多... ]
CPU affinity ：中文唤作“CPU亲和力”，是指在CMP架构下，能够将一个或多个进程绑定到一个或多个处理器上运行。[更多... ]
一、在Linux上修改进程的“CPU亲和力”
在Linux上，可以通过 taskset 命令进行修改。以Ubuntu为例，运行如下命令可以安装taskset 工具。
# apt-get install schedutils
对运行中的进程，文档上说可以用下面的命令，把CPU#1 #2 #3分配给PID为2345的进程：
# taskset -cp 1,2,3 2345
但我尝试没奏效 ，于是我关掉了MySQL，并用taskset将它启动：
# taskset -c 1,2,3 /etc/init.d/mysql start
对于其他进程，也可如此处理（nginx除外，详见下文）。之后用top查看CPU的使用情况，原来空闲的#1 #2 #3，已经在辛勤工作了。
二、配置nginx绑定CPU
刚才说nginx除外，是因为nginx提供了更精确的控制。
在conf/nginx.conf 中，有如下一行：
worker_processes 1;
这是用来配置nginx启动几个工作进程的，默认为1。而nginx还支持一个名为worker_cpu_affinity的配置项，也就是说，nginx可以为每个工作进程绑定CPU 。我做了如下配置：
worker_processes 3; worker_cpu_affinity 0010 0100 1000;
这里0010 0100 1000是掩码，分别代表第2、3、4颗cpu核心。
重启nginx后，3个工作进程就可以各自用各自的CPU了。
三、刨根问底
如果自己写代码，要把进程绑定到CPU，该怎么做？可以用sched_setaffinity 函数。在Linux上，这会触发一次系统调用 。
如果父进程设置了affinity，之后其创建的子进程是否会有同样的属性？我发现子进程确实继承了父进程的affinity属性。
四、Windows？
在Windows上修改“CPU亲和力”，可以通过任务管理器搞定。
* 个人感觉，Windows系统中翻译的“处理器关系”比“CPU亲和力”容易理解点儿
—————–
进行了这样的修改后，即使系统负载达到3以上，不带缓存打开blogkid.net首页（有40多次查询）依然顺畅；以前一旦负载超过了1.5，响应就很慢了。效果很明显。
另外还有一篇文章:详细的用程序例子分析了CPU affinity (亲和力)
from:http://fuzhong1983.blog.163.com/blog/static/16847052009112413613231/
觉得人为控制一下cpu的绑定还是有用处的
1、linux的SMP负载均衡是基于进程数的，每个cpu都有一个可执行进程队列，只有当其中一个cpu的可执行队列里进程数比其他cpu队列进程数多25%时，才会将进程移动到另外空闲cpu上，也就是说cpu0上的进程数应该是比其他cpu上多，但是会在25%以内
2、我们的业务中耗费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的趋势越来越大了. 有时候为了更好地操作机器, 需要将某个进程绑定到具体的CPU上去. 下面给出了一个进程绑定到具体的CPU上去的一个例子.
view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#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;
}
#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
///////////////////////////////////////////////
CPU Affinity (CPU亲合力)
CPU亲合力就是指在Linux系统中能够将一个或多个进程绑定到一个或多个处理器上运行.
一个进程的CPU亲合力掩码决定了该进程将在哪个或哪几个CPU上运行.在一个多处理器系统中,设置CPU亲合力的掩码可能会获得更好的性能.
一个CPU的亲合力掩码用一个cpu_set_t结构体来表示一个CPU集合,下面的几个宏分别对这个掩码集进行操作:
CPU_ZERO() 清空一个集合
CPU_SET()与CPU_CLR()分别对将一个给定的CPU号加到一个集合或者从一个集合中去掉.
CPU_ISSET()检查一个CPU号是否在这个集合中.
其实这几个的用法与select()函数那几个调用差不多.
下面两个函数就是最主要的了:
sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数设置进程为pid的这个进程,让它运行在mask所设定的CPU上.如果pid的值为0,则表示指定的是当前进程,使当前进程运行在mask所设定的那些CPU上.第二个参数cpusetsize是
mask所指定的数的长度.通常设定为sizeof(cpu_set_t).如果当前pid所指定的CPU此时没有运行在mask所指定的任意一个CPU上,则该指定的进程会从其它CPU上迁移到mask的指定的
一个CPU上运行.
sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
该函数获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中.即获得指定pid当前可以运行在哪些CPU上.同样,如果pid的值为0.也表示的是当前进程.
这几个宏与函数的具体用法前面已经有讲解.
关于cpu_set_t的定义
# define __CPU_SETSIZE 1024
# define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
# define __CPUELT(cpu) ((cpu) / __NCPUBITS)
# define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
typedef struct
{
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
# define __CPU_ZERO(cpusetp) /
do { /
unsigned int __i; /
cpu_set_t *__arr = (cpusetp); /
for (__i = 0; __i < sizeof (cpu_set_t) / sizeof (__cpu_mask); ++__i) /
__arr->__bits[__i] = 0; /
} while (0)
# define __CPU_SET(cpu, cpusetp) /
((cpusetp)->__bits[__CPUELT (cpu)] |= __CPUMASK (cpu))
# define __CPU_CLR(cpu, cpusetp) /
((cpusetp)->__bits[__CPUELT (cpu)] &= ~__CPUMASK (cpu))
# define __CPU_ISSET(cpu, cpusetp) /
(((cpusetp)->__bits[__CPUELT (cpu)] & __CPUMASK (cpu)) != 0)
在我的机器上sizeof(cpu_set_t)的大小为128,即一共有1024位.第一位代表一个CPU号.某一位为1则表示某进程可以运行在该位所代表的cpu上.例如
CPU_SET(1, &mask);
则mask所对应的第2位被设置为1.
此时如果printf("%d/n", mask.__bits[0]);就打印出2.表示第2位被置为1了.
具体我是参考man sched_setaffinity文档中的函数的.
然后再参考了一下IBM的 developerWorks上的一个讲解.
http://www.ibm.com/developerworks/cn/linux/l-affinity.html
其中的概念：
CPU亲和性（affinity）sched_setaffinity() 和 sched_getaffinity()
分类： Linux基础编程2012-05-2219:24 949人阅读 评论(0) 收藏 举报
简单地说，CPU 亲和性（affinity） 就是进程要在某个给定的 CPU 上尽量长时间地运行而不被迁移到其他处理器的倾向性。Linux 内核进程调度器天生就具有被称为 软 CPU 亲和性（affinity） 的特性，这意味着进程通常不会在处理器之间频繁迁移。这种状态正是我们希望的，因为进程迁移的频率小就意味着产生的负载小。
2.6 版本的 Linux 内核还包含了一种机制，它让开发人员可以编程实现 硬 CPU 亲和性（affinity）。这意味着应用程序可以显式地指定进程在哪个（或哪些）处理器上运行。
什么是 Linux 内核硬亲和性（affinity）？
在 Linux 内核中，所有的进程都有一个相关的数据结构，称为
task_struct。这个结构非常重要，原因有很多；其中与 亲和性（affinity）相关度最高的是
cpus_allowed位掩码。这个位掩码由 n 位组成，与系统中的 n 个逻辑处理器一一对应。 具有 4 个物理 CPU 的系统可以有 4 位。如果这些 CPU 都启用了超线程，那么这个系统就有一个 8 位的位掩码。
如果为给定的进程设置了给定的位，那么这个进程就可以在相关的 CPU 上运行。因此，如果一个进程可以在任何 CPU 上运行，并且能够根据需要在处理器之间进行迁移，那么位掩码就全是 1。实际上，这就是 Linux 中进程的缺省状态。
Linux 内核 API 提供了一些方法，让用户可以修改位掩码或查看当前的位掩码：
sched_set_affinity()（用来修改位掩码）
sched_get_affinity()（用来查看当前的位掩码）
注意，
cpu_affinity会被传递给子线程，因此应该适当地调用
sched_set_affinity。
为什么应该使用硬亲和性（affinity）？
通常 Linux 内核都可以很好地对进程进行调度，在应该运行的地方运行进程（这就是说，在可用的处理器上运行并获得很好的整体性能）。内核包含了一些用来检测 CPU 之间任务负载迁移的算法，可以启用进程迁移来降低繁忙的处理器的压力。
一般情况下，在应用程序中只需使用缺省的调度器行为。然而，您可能会希望修改这些缺省行为以实现性能的优化。让我们来看一下使用硬亲和性（affinity） 的 3 个原因。
原因 1. 有大量计算要做
基于大量计算的情形通常出现在科学和理论计算中，但是通用领域的计算也可能出现这种情况。一个常见的标志是您发现自己的应用程序要在多处理器的机器上花费大量的计算时间。
原因 2. 您在测试复杂的应用程序
测试复杂软件是我们对内核的亲和性（affinity）技术感兴趣的另外一个原因。考虑一个需要进行线性可伸缩性测试的应用程序。有些产品声明可以在 使用更多硬件 时执行得更好。
我们不用购买多台机器（为每种处理器配置都购买一台机器），而是可以：
购买一台多处理器的机器
不断增加分配的处理器
测量每秒的事务数
评估结果的可伸缩性
如果应用程序随着 CPU 的增加可以线性地伸缩，那么每秒事务数和 CPU 个数之间应该会是线性的关系（例如斜线图 —— 请参阅下一节的内容）。这样建模可以确定应用程序是否可以有效地使用底层硬件。
Amdahl 法则
Amdahl 法则是有关使用并行处理器来解决问题相对于只使用一个串行处理器来解决问题的加速比的法则。加速比（Speedup） 等于串行执行（只使用一个处理器）的时间除以程序并行执行（使用多个处理器）的时间：T(1) S = ------ T(j) |
T(j)是在使用
j个处理器执行程序时所花费的时间。
Amdahl 法则说明这种加速比在现实中可能并不会发生，但是可以非常接近于该值。对于通常情况来说，我们可以推论出每个程序都有一些串行的组件。随着问题集不断变大，串行组件最终会在优化解决方案时间方面达到一个上限。
Amdahl 法则在希望保持高 CPU 缓存命中率时尤其重要。如果一个给定的进程迁移到其他地方去了，那么它就失去了利用 CPU 缓存的优势。实际上，如果正在使用的 CPU 需要为自己缓存一些特殊的数据，那么所有其他 CPU 都会使这些数据在自己的缓存中失效。
因此，如果有多个线程都需要相同的数据，那么将这些线程绑定到一个特定的 CPU 上是非常有意义的，这样就确保它们可以访问相同的缓存数据（或者至少可以提高缓存的命中率）。否则，这些线程可能会在不同的 CPU 上执行，这样会频繁地使其他缓存项失效。
原因 3. 您正在运行时间敏感的、决定性的进程
我们对 CPU 亲和性（affinity）感兴趣的最后一个原因是实时（对时间敏感的）进程。例如，您可能会希望使用硬亲和性（affinity）来指定一个 8 路主机上的某个处理器，而同时允许其他 7 个处理器处理所有普通的系统调度。这种做法确保长时间运行、对时间敏感的应用程序可以得到运行，同时可以允许其他应用程序独占其余的计算资源。
下面的样例应用程序显示了这是如何工作的。
如何利用硬亲和性（affinity）
现在让我们来设计一个程序，它可以让 Linux 系统非常繁忙。可以使用前面介绍的系统调用和另外一些用来说明系统中有多少处理器的 API 来构建这个应用程序。实际上，我们的目标是编写这样一个程序：它可以让系统中的每个处理器都繁忙几秒钟。
清单 1. 让处理器繁忙
/* This method will create threads, then bind each to its own cpu. */
bool do_cpu_stress(int numthreads)
{
int ret = TRUE;
int created_thread = 0;
/* We need a thread for each cpu we have... */
while ( created_thread < numthreads - 1 )
{
int mypid = fork();
if (mypid == 0) /* Child process */
{
printf("\tCreating Child Thread: #%i\n", created_thread);
break;
}
else /* Only parent executes this */
{
/* Continue looping until we spawned enough threads! */ ;
created_thread++;
}
}
/* NOTE: All threads execute code from here down! */ |
正如您可以看到的一样，这段代码只是通过 fork 调用简单地创建一组线程。每个线程都执行这个方法中后面的代码。现在我们让每个线程都将亲和性（affinity）设置为自己的 CPU。
清单 2. 为每个线程设置 CPU 亲和性（affinity）
cpu_set_t mask;
/* CPU_ZERO initializes all the bits in the mask to zero. */
CPU_ZERO( &mask );
/* CPU_SET sets only the bit corresponding to cpu. */
CPU_SET( created_thread, &mask );
/* sched_setaffinity returns 0 in success */
if( sched_setaffinity( 0, sizeof(mask), &mask ) == -1 )
{
printf("WARNING: Could not set CPU Affinity, continuing...\n");
} |
如果程序可以执行到这儿，那么我们的线程就已经设置了自己的亲和性（affinity）。调用
sched_setaffinity会设置由
pid所引用的进程的 CPU 亲和性（affinity）掩码。如果
pid为 0，那么就使用当前进程。
亲和性（affinity）掩码是使用在
mask中存储的位掩码来表示的。最低位对应于系统中的第一个逻辑处理器，而最高位则对应于系统中最后一个逻辑处理器。
每个设置的位都对应一个可以合法调度的 CPU，而未设置的位则对应一个不可调度的 CPU。换而言之，进程都被绑定了，只能在那些对应位被设置了的处理器上运行。通常，掩码中的所有位都被置位了。这些线程的亲和性（affinity）都会传递给从它们派生的子进程中。
注意不应该直接修改位掩码。应该使用下面的宏。虽然在我们的例子中并没有全部使用这些宏，但是在本文中还是详细列出了这些宏，您在自己的程序中可能需要这些宏。
清单 3. 间接修改位掩码的宏
void CPU_ZERO (cpu_set_t *set) 这个宏对 CPU 集 set 进行初始化，将其设置为空集。 void CPU_SET (int cpu, cpu_set_t *set) 这个宏将 cpu 加入 CPU 集 set 中。 void CPU_CLR (int cpu, cpu_set_t *set) 这个宏将 cpu 从 CPU 集 set 中删除。 int CPU_ISSET (int cpu, const cpu_set_t *set) 如果 cpu 是 CPU 集 set 的一员，这个宏就返回一个非零值（true），否则就返回零（false）。 |
对于本文来说，样例代码会继续让每个线程都执行某些计算量较大的操作。
清单 4. 每个线程都执行一个计算敏感的操作
/* Now we have a single thread bound to each cpu on the system */
int computation_res = do_cpu_expensive_op(41);
cpu_set_t mycpuid;
sched_getaffinity(0, sizeof(mycpuid), &mycpuid);
if ( check_cpu_expensive_op(computation_res) )
{
printf("SUCCESS: Thread completed, and PASSED integrity check!\n",
mycpuid);
ret = TRUE;
}
else
{
printf("FAILURE: Thread failed integrity check!\n",
mycpuid);
ret = FALSE;
}
return ret;
} |
现在您已经了解了在 Linux 2.6 版本的内核中设置 CPU 亲和性（affinity）的基本知识。接下来，我们使用一个
main程序来封装这些方法，它使用一个用户指定的参数来说明要让多少个 CPU 繁忙。我们可以使用另外一个方法来确定系统中有多少个处理器：
int NUM_PROCS = sysconf(_SC_NPROCESSORS_CONF);
这个方法让程序能够自己确定要让多少个处理器保持繁忙，例如缺省让所有的处理器都处于繁忙状态，并允许用户指定系统中实际处理器范围的一个子集。
运行样例程序
当运行前面介绍的样例程序时，可以使用很多工具来查看 CPU 是否是繁忙的。如果只是简单地进行测试，可以使用 Linux 命令
top。在运行
top命令时按下 “1” 键，可以看到每个 CPU 执行进程所占用的百分比。
结束语
这个样例程序虽然非常简单，但是它却展示了使用 Linux 内核中实现的硬亲和性（affinity）的基本知识。（任何使用这段代码的应用程序都无疑会做一些更有意义的事情。）了解了 CPU 亲和性（affinity）内核 API 的基本知识，您就可以从复杂的应用程序中榨取出最后一点儿性能了。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- /dev/sdc1 is apparently in use by the system; will not make a filesystem here!
- Android开发虚拟机的各种分辨率
- 对编译时异常和运行时异常的理解
- 屏幕宽高的获取
- iOS解锁界面的"滑动来解锁"闪烁动画效果
- Linux中flock和fcntl区别
- SwipeRecyclerView
- (转)JavaMail邮件发送-发送一个文本邮件和一些问题说明
- string 类的实现
- JAVA书籍TOP10(转)
- 基于51单片机的74HC164驱动六位数码管动态显示程序
- 安卓图表引擎AChartEngine(一) - 简介
- UI控件之SeekBar（拖动条）
- TCP协议详解---上
- MyBatis中的resultType和resultMap
- php header 设置文件下载
- oracle 断电启动失败：ORA-00600: internal error code, arguments
- redis管理工具——Redis Desktop Manager
- 学习总结-Active Directory 域服务管理10-信任管理
- leetcode：Longest Substring Without Repeating Characters