linux下让进程运行在指定的cpu上
收藏
最近负责的svr压力比较大，业务逻辑有点复杂,能优化的地方已经全部优化了，
目前每秒3k次，cpu负载还是比较高
top看一下，4核的cpu负载不是太均衡，打算考虑一下将业务进程指定到3个cpu上运行，另外一个cpu专门负责处理网络收发包；打算尝试一下，如果还是不行，再过段时间，访问量再增加的话，就要加机器了，呜呜
补充：今天测试了一下，效果挺好，同样进程数的情况下，进行cpu绑定
每个cpu都利用起来了，负载也比不绑定的情况下好了很多
分析一下有效果的原因：
看了《linux内核设计与实现》的42节，觉得人为控制一下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上去的一个例子.
viewplaincopytoclipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······15001.#include<stdlib.h>
02.#include<stdio.h>
03.#include<sys/types.h>
04.#include<sys/sysinfo.h>
05.#include<unistd.h>
06.
07.#define__USE_GNU
08.#include<sched.h>
09.#include<ctype.h>
10.#include<string.h>
11.
12.intmain(intargc,char*argv[])
13.{
14.intnum=sysconf(_SC_NPROCESSORS_CONF);
15.intcreated_thread=0;
16.intmyid;
17.inti;
18.intj=0;
19.
20.cpu_set_tmask;
21.cpu_set_tget;
22.
23.if(argc!=2)
24.{
25.printf("usage:./cpunum\n");
26.exit(1);
27.}
28.
29.myid=atoi(argv[1]);
30.
31.printf("systemhas%iprocessor(s).\n",num);
32.
33.CPU_ZERO(&mask);
34.CPU_SET(myid,&mask);
35.
36.if(sched_setaffinity(0,sizeof(mask),&mask)==-1)
37.{
38.printf("warning:couldnotsetCPUaffinity,continuing...\n");
39.}
40.while(1)
41.{
42.
43.CPU_ZERO(&get);
44.if(sched_getaffinity(0,sizeof(get),&get)==-1)
45.{
46.printf("warning:coundnotgetcpuaffinity,continuing...\n");
47.}
48.for(i=0;i<num;i++)
49.{
50.if(CPU_ISSET(i,&get))
51.{
52.printf("thisprocess%disrunningprocessor:%d\n",getpid(),i);
53.}
54.}
55.}
56.return0;
57.}
#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>
intmain(intargc,char*argv[])
{
intnum=sysconf(_SC_NPROCESSORS_CONF);
intcreated_thread=0;
intmyid;
inti;
intj=0;
cpu_set_tmask;
cpu_set_tget;
if(argc!=2)
{
printf("usage:./cpunum\n");
exit(1);
}
myid=atoi(argv[1]);
printf("systemhas%iprocessor(s).\n",num);
CPU_ZERO(&mask);
CPU_SET(myid,&mask);
if(sched_setaffinity(0,sizeof(mask),&mask)==-1)
{
printf("warning:couldnotsetCPUaffinity,continuing...\n");
}
while(1)
{
CPU_ZERO(&get);
if(sched_getaffinity(0,sizeof(get),&get)==-1)
{
printf("warning:coundnotgetcpuaffinity,continuing...\n");
}
for(i=0;i<num;i++)
{
if(CPU_ISSET(i,&get))
{
printf("thisprocess%disrunningprocessor:%d\n",getpid(),i);
}
}
}
return0;
}
下面是在两个终端分别执行了./cpu0./cpu2后得到的结果.效果比较明显.
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
///////////////////////////////////////////////
CPUAffinity(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_tpid,unsignedintcpusetsize,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_tpid,unsignedintcpusetsize,cpu_set_t*mask)
该函数获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中.即获得指定pid当前可以运行在哪些CPU上.同样,如果pid的值为0.也表示的是当前进程.
这几个宏与函数的具体用法前面已经有讲解.
关于cpu_set_t的定义
#define__CPU_SETSIZE1024
#define__NCPUBITS(8*sizeof(__cpu_mask))
typedefunsignedlongint__cpu_mask;
#define__CPUELT(cpu)((cpu)/__NCPUBITS)
#define__CPUMASK(cpu)((__cpu_mask)1<<((cpu)%__NCPUBITS))
typedefstruct
{
__cpu_mask__bits[__CPU_SETSIZE/__NCPUBITS];
}cpu_set_t;
#define__CPU_ZERO(cpusetp)\
do{\
unsignedint__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了.
具体我是参考mansched_setaffinity文档中的函数的.
然后再参考了一下IBM的developerWorks上的一个讲解
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/eroswang/archive/2009/07/09/4336093.aspx