> Linux教程 > Linux学习 >

linux 进程线程时间片

 首先申明,我是菜鸟.菜到什么程度,大家看看下面的代码. 
代码要求:取得1000次单独创建进程的时间. 
[code:1:fdac913669]#include  
#include 
#include 
#include  
#include  
 
 
strut timeval { 
long tv_sec; /* 秒数 */ 
long tv_usec; /* 微秒数 */ 
}; 
 
int gettimeofday(struct timeval *tv,struct timezone *tz); 
 
 
main() 
struct timeval tpstart,tpend; 
float timeuse; 
unsigned int i; 
 
gettimeofday(&tpstart,NULL); 
 
for(i=0;i<1000;i++) 
pid_t fork(); 
 
gettimeofday(&tpend,NULL); 
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec; 
timeuse/=1000000; 
printf("Used Time:%f/n",timeuse); 
exit(0); 
}  
[/code:1:fdac913669] 
 
 
取得线程时间: 
//线程 
不知道该怎么做.因为int pthread_create(pthread_t * thread, pthread_attr_t * attr,  
void * (*start_routine)(void *), void * arg) 
需要返回一个参数,比如: 
int ret; 
ret=pthread_create(pthread_t * thread, NULL, void * (*start_routine)(void *), void * arg); 
 
那么时间当中就包含了赋值的时间了. 
 
[b:fdac913669]不知道大家对线程和进程的创建的时间取得有什么好的建议呢?[/b:fdac913669]
 
 aero 回复于:2003-08-10 21:01:44
偶觉得,已经不菜了。 
如果你菜,那偶就还是鸟蛋了。
 
 coolhome 回复于:2003-08-10 20:27:00
[code:1:334e6e5b17] 
include <sys/types.h> 
#include <sys/stat.h> 
#include <stdio.h> 
 
 
struct timeval { 
long tv_sec; /* 秒数 */ 
long tv_usec; /* 微秒数 */ 
}; 
 
int gettimeofday(struct timeval *tv,struct timezone *tz); 
 
 
main() 
 struct timeval tpstart,tpend; 
 float  timeuse; 
 unsigned int i; 
int rc; 
 
int p1 = 0; 
 
 gettimeofday(&tpstart,NULL); 
 for(i=0;i<1000;i++) 
 
 
rc = pthread_create(&sid, NULL, (void*)&threads, (void *)&p1)) 
 
 
 
 gettimeofday(&tpend,NULL); 
 timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec; 
 timeuse/=1000000; 
 printf("Used Timef/n",timeuse); 
 exit(0); 
[/code:1:334e6e5b17]
 
 coolhome 回复于:2003-08-10 20:27:25
上面取得的是线程的1000次创建的时间
 
 jackie God 回复于:2003-08-10 22:09:00
虽然不太懂但是也要说两句!不知道这几条行不行!? 
用Real_timer Jiffy,或者SoftIRQ, 
Task_struct中有一个start_time 是进程创建时的Jiffies。 
但是线程具体情况不太清楚! 
 
 
还有,好像是这样 
strut timeval {  
int tv_sec; /* 秒数 */  
int tv_usec; /* 微秒数 */  
};  
struct timespec是long的纳妙!
 
 coolhome 回复于:2003-08-11 19:00:09
jackie God    的意思是不是说:strut timeval取得不是一个正确的时间呢? 
应该使用struct timespec? 
我不是很清楚. 
另外:以上两个程序是不是正确还没有确定,我机器上无linux,这几个是我随手编出来的.没有验证过.
 
 无双 回复于:2003-08-11 19:25:54
这两个都不会很准确吧 
如果不是使用计帐时间的话 
 
因为系统中同时有多个进程在进行 
不可能只让你独占CPU的
 
 aero 回复于:2003-08-11 20:16:32
从原理上讲,偶同意无双的。
 
 jackie God 回复于:2003-08-12 13:33:23
应该使用struct timespec! 
既然不记帐,可以使用atomic操作!
 
 betty 回复于:2003-08-31 22:59:45
我不懂了,gettimeofday可以取得纳秒的时间吗? 
还有,gettimeofday函数本身的开销怎么去掉?
 
 amble_shisu 回复于:2003-09-03 17:48:46
gettimeofday的开销我计算过,大概0.6ms; 
其实也不会太准,因为中间万一调度就 
而且关于那个线程的,pthread_create创建的线程可能在返回以前就已经运行了,甚至运行结束了. 
你这样创建一千次取平均值,未免太儿戏了.
 
 amble_shisu 回复于:2003-09-03 17:50:25
gettimeofday精确到百万分之一秒
 
 amble_shisu 回复于:2003-09-03 18:08:11
用原子操作也是一种方法 ,如果能保证我的系统里面只有#0号进程和我的进程,那无所谓.
 
 amble_shisu 回复于:2003-09-03 18:09:58
否则你不可锁掉其他进程.
 
 betty 回复于:2003-09-03 23:18:04
是不是不同的redhat版本不同就会有不同的命令?在人家机器上可以通过的程序在我机器上不行 
 
 sky-walker 回复于:2003-09-04 00:25:16
大家将就将就吧,分时操作系统的时间获得本身就是个不精确值, 
也不可能只计算一个用户程序,至少编码时要用一下setpriority(), 
把优先级先设置一下; 
至于时间的计算,我想getrusage()可以把systemcall时间和user 
running时间分开(也是不精确的)
 
 renguoh 回复于:2003-09-04 16:56:49
不知道大家有没有仔细看楼主的程序,我认为这一块肯定问题 
   for(i=0;i<1000;i++)  
   pid_t fork();  
这样不是创建1000子进程了,而是2**1000子进程了,因为在你 
创建的子进程中,也在不断的执行for循环的。如果运行这个 
程序的话,那么系统的资源肯定马上就会枯竭的。因此,因该将 
循环的次数变成10,那么就是创建1024个进程了。为了可以更加 
清楚地看见进程创建的过程,可以这样来做: 
    for(i=0;i<1000;i++)  
    { 
       pid_t pid1 = fork();  
       printf("%dth process have created,The process ID is",i.pid1); 
    } 
 
如果要确定fork一个子进程的时间,那么应该了解 
内核是如何来调度和控制进程的。我们知道,Unix是一个分时 
操作系统。每一个进程都是通过占用CPU的时间片来获得执行的。 
当然,一个进程占用的时间片概率由该进程的优先权阀值来确定, 
如果它的优先权很高,那么,当它用完CPU时间片以后,再次获得 
CPU的时间片的概率也就越高,否则的话在系统资源比较紧张的话 
概率就比较低,可能需要很长的一个时间才能再次获得对CPU的占有。 
因此,可能每次fork子进程的时间都是不一样的。如果需要在较短的 
时间内来创建子进程,那么就必须提高父进程的优先权,这可以由 
系统调用nice来实现。 
在基于传统的对换系统中,父进程的创建是由内核来去确定的,由于 
在本程序中仅仅是创建子进程,没有其他操作,因此,父进程创建子 
进程的大部分时间主要是在创建子进程的数据区和栈区上,而子进程的 
正文区是和父进程共享的。因此,本例程序应该写成这样: 
#include  <stdio.h> 
#include  <sys/types.h> 
#include  <unistd.h>  
 
 
strut timeval {  
long tv_sec; /* 秒数 */  
long tv_usec; /* 微秒数 */  
};  
 
int gettimeofday(struct timeval *tv,struct timezone *tz);  
 
 
main()  
{  
struct timeval tpstart,tpend;  
float timeuse;  
unsigned int i; 
pid_t pid1;  
 
gettimeofday(&tpstart,NULL);  
nice(0); 
for(i=0;i<1000;i++)  
    pid1 = fork(); 
    switch(pid1) 
    { 
case 0: 
    exit(0); 
default: 
                   printf("%dth process have created,The process ID   
                                                                is",i.pid1); 
    wait((int*)0); 
    } 
gettimeofday(&tpend,NULL);  
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;  
timeuse/=1000000;  
printf("Used Time:%f/n",timeuse);  
return 0;  
}
 
 betty 回复于:2003-09-04 23:54:40
renguoh同学,你的这个程序误差会过大.其中swich等其他的函数会影响fork时间. 
 
 renguoh 回复于:2003-09-05 11:01:52
上面写的程序只是让我们能看得更清楚子进程创建的过程,当然,你为了纯粹创建1000个进程,不考虑子进程退出后变成僵尸进程,就只可以这样了: 
for(i=0;i<10;i++)  
pid_t pid1 = fork();  
 
不知道betty有没有仔细看楼主的程序,这个程序肯定是取不到进程创建的时间的,因为每个子进程都会不断执行gettimeofday(&tpend,NULL)这个函数以及以下的代码(我已经在Solaris 8系统上试过) 
 
其实你所说的swith函数和printf函数相对进程创建的时间来讲,是很小的,可能printf函数花费的时间要比switch函数要稍微长 一点,如果将printf函数屏蔽掉,时间可能会短一点,这两种情况我都试过,结果是前一种情况为0.133秒,后一种情况是0.113666秒。如果你 觉得有更好的方法,请告诉我,我们可以探讨探讨。 
 
我在做测试的时候用的程序是(在Solaris 8操作系统上运行过): 
#include  <stdio.h> 
#include  <sys/types.h> 
#include  <unistd.h>  
#include  <sys/time.h> 
 
int main()  
{  
struct timeval tpstart,tpend;  
float timeuse;  
unsigned int i; 
pid_t pid1;  
 
gettimeofday(&tpstart,NULL);  
nice(0); 
for(i=0;i<1000;i++)  
    pid1 = fork(); 
    switch(pid1) 
    { 
case 0: 
    exit(0); 
default: 
            printf("%dth process have created,The process ID is",i.pid1);   
             //可以根据情况将上一行屏蔽 
    wait((int*)0); 
    } 
gettimeofday(&tpend,NULL);  
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;  
timeuse/=1000000;  
printf("Used Time:%f/n",timeuse);  
return 0;  
}  
 
没有将printf函数屏蔽掉执行的结果,Used time: 0.133644 
      将printf函数屏蔽掉执行的结果, Used time: 0.112244 
 
当然,每次执行的结果可能有一点偏差!
 
 sqzhong 回复于:2003-09-08 18:19:07
因为我们要的是仅仅创建进程的时间,楼上的程序太繁琐了,所以结果太不精确了。我们得到的结果是创建进程大约130微妙。(redhat8.0)
 

 



(责任编辑:IT)