linux内核编程实验三

内核的定时机制实验

问题 A
使用ITIMER_REAL型定时器实现一个gettimeofday()，将它设置为每秒产生一个信号，
并计算已经经过的秒数。
问题 B
使用以上实现的 gettimeofday()实现一个精确到微秒级的“闹钟”。
问题 C
实现以上一个父进程和两个子进程并发递归计算不同项数的fibonacci序列的程序，
分析每个进程三种类型定时器测出的时间关系。

---

解决问题A
一直被实现一个gettimeofday()这句话困惑，在不停思考如何实现这个方法。这是一个系统调用，由操作系统提供，涉及底层计算机架构的知识。这与我们的实验目的不符。gettimeofday函数用来获取系统时间的秒数、微秒数。通常可以在程序执行开始前获得一次时间，程序执行结束后获得一次时间，通过差的计算得到程序执行时间。(以1970年1月1日0时0分0秒为时间起点)
那么问题A的目的就明确了，就是实现为程序记时的功能，但不使用gettimeofday，要求使用setitimer和getitimer而已。
首先需要写一个SIGALRM信号处理函数，该函数用来计算时间，通过signal函数绑定。然后setitimer()。执行程序。最后通过getitimer获得计时器的值，与前面的时间一起计算出程序最终用时。

解决问题B
闹钟大家都用过，初始设置一个时间，到时间之后对用户产生提醒。因此，首先需要用户输入精确的时间，然后使用问题A的步骤绑定信号处理，设置计时器，超时之后，提醒用户时间到。获取系统当前时间并转化成微秒时间戳，然后将用户设置的时间转换成微秒时间戳，计算差值。设置计时器，让计时器只工作一次即可。

解决问题C
fork两个进程与父进程一起求fibonacci数。与问题A类似，只不过需要使用三种定时器。求fibonacci数时函数尽量选择递归，数不可太大，也不能过小，20-40之间即可，可以让实验结果更加明显。

---

p_realt.it_value.tv_sec = 9;
p_realt.it_value.tv_usec = 999999;
p_realt.it_interval.tv_sec = 9;
p_realt.it_interval.tv_usec = 999999;
这里其实是9秒999999微秒，但是按照10秒计算，理论上误差1微秒，实际上由于计算机执行速度的问题，这点误差可忽略。
当p_realt.it_interval.tv_sec = 9;p_realt.it_interval.tv_usec = 999999;
设置为0时，计时器只工作一次，否则计时器循环工作，it_value的值将变成it_interval。

---

代码如下：

#include 
#include 
#include 
#include 
#include  //for time()
#include  //for itimeval
#include  //for pid_t
#include  //for waitpid

void psig_real(int signum); //父进程3个信号处理函数
void psig_virtual(int signum);
void psig_prof(int signum);
void c1sig_real(int signum); //子进程1的3个信号处理
void c1sig_virtual(int signum);
void c1sig_prof(int signum);
void c2sig_real(int signum); //子进程2的3个信号处理
void c2sig_virtual(int signum);
void c2sig_prof(int signum);

long fibonacci(unsigned int n); //求斐波那契

//记时变量
long p_real_secs=0,c1_real_secs=0,c2_real_secs=0;
long p_virtual_secs=0,c1_virtual_secs=0,c2_virtual_secs=0;
long p_prof_secs= 0,c1_prof_secs=0, c2_prof_secs=0;

//计时器结构体
struct itimerval p_realt, c1_realt, c2_realt;
struct itimerval p_virtt, c1_virtt, c2_virtt;
struct itimerval p_proft, c1_proft, c2_proft;

//part A的信号处理
void psig_real_gettime(int signum)
{
    p_real_secs += 1;
}

//实现具有gettimeofday功能 ，接收一个函数
void mygettimeofday(unsigned int i,long (*timefunction)(unsigned int))
{
    signal(SIGALRM,psig_real_gettime);
    p_realt.it_value.tv_sec = 0; //0 sec
    p_realt.it_value.tv_usec = 999999; //999999 usec
    p_realt.it_interval.tv_sec = 0;
    p_realt.it_interval.tv_usec = 999999;
    setitimer(ITIMER_REAL,&p_realt,NULL);
    timefunction(i);
    getitimer(ITIMER_REAL,&p_realt);
    printf("cost time %ld Sec : %ld Msec\n",
           p_real_secs,
           (999999 - p_realt.it_value.tv_usec) / 1000);
}

int wakeupme = 0; //part B闹钟

void dealalarm(int signum) //闹钟处理函数
{
    wakeupme = 1;
}

int main(int argc,char **argv)
{
    long fib = 0, microsecond;
    pid_t pid1, pid2;
    int msecond, usecond;
    struct timeval tv;
    if(argv[1][0] == '-' && argv[1][1] == 'a' && argc == 3)
    {
    printf("-----PART A-----\n");
    mygettimeofday(atoi(argv[2]),fibonacci);
    return 0;
    }

    else if(argv[1][0] == '-' && argv[1][1] == 'b')
    {
        printf("-----PART B-----\n");
    struct timeval tv;
    gettimeofday(&tv, NULL);
    struct tm *tmptime;
    tmptime = localtime(&tv.tv_sec);
    printf("now time > %d-%d-%d %d:%d:%d:%d:%d\n",tmptime->tm_year+1900,tmptime->tm_mon+1,tmptime->tm_mday,tmptime->tm_hour,tmptime->tm_min,tmptime->tm_sec,(int)tv.tv_usec/1000,(int)tv.tv_usec%1000);

    struct tm inputtime;
    int year, month, day, hour, minute, second;
    printf("set alarm : ");
    scanf("%d-%d-%d %d:%d:%d:%d:%d",&year,&month,&day,&hour, &minute,&second,&msecond,&usecond);
          inputtime.tm_year = year - 1900;
              inputtime.tm_mon = month - 1;
              inputtime.tm_mday = day;
              inputtime.tm_hour = hour;
              inputtime.tm_min = minute;
              inputtime.tm_sec = second;
              inputtime.tm_isdst = 0;
              inputtime.tm_wday = 0;
              inputtime.tm_yday = 0;
    microsecond = mktime(&inputtime) * 1000000 +
                      msecond * 1000 + usecond;
    microsecond -= tv.tv_sec * 1000000 + tv.tv_usec;
    signal(SIGALRM,dealalarm);

        p_realt.it_value.tv_sec = microsecond / 1000000;

        p_realt.it_value.tv_usec = microsecond % 1000000;

        p_realt.it_interval.tv_sec = 0;

        p_realt.it_interval.tv_usec = 0;

        setitimer(ITIMER_REAL,&p_realt,NULL);
    while(!wakeupme);
    printf("wake time > %d-%d-%d %d:%d:%d:%d:%d\n",inputtime.tm_year+1900,inputtime.tm_mon+1,inputtime.tm_mday,inputtime.tm_hour,inputtime.tm_min,inputtime.tm_sec,msecond,usecond);

    return 0;

    }

    else if(argv[1][0] == '-' && argv[1][1] == 'c' && argc == 5)

    {

        printf("-----PART C-----\n");

        //bind signal and function for parent process

        signal(SIGALRM,psig_real);

        signal(SIGVTALRM,psig_virtual);

        signal(SIGPROF,psig_prof);

        //init parent process 3 timer

        p_realt.it_interval.tv_sec = 9;

        p_realt.it_interval.tv_usec = 999999;

        p_realt.it_value.tv_sec = 9;

        p_realt.it_value.tv_usec = 999999;

        setitimer(ITIMER_REAL,&p_realt,NULL);



        p_virtt.it_interval.tv_sec = 9;

        p_virtt.it_interval.tv_usec = 999999;

        p_virtt.it_value.tv_sec = 9;

        p_virtt.it_value.tv_usec = 999999;

        setitimer(ITIMER_VIRTUAL,&p_virtt,NULL);



        p_proft.it_interval.tv_sec = 9;

        p_proft.it_interval.tv_usec = 999999;

        p_proft.it_value.tv_sec = 9;

        p_proft.it_value.tv_usec = 999999;

        setitimer(ITIMER_PROF,&p_proft,NULL);



        pid1 = fork();

        if(pid1==0)

        {

        //bind signal and function for child1 process

        signal(SIGALRM,c1sig_real);

        signal(SIGVTALRM,c1sig_virtual);

        signal(SIGPROF,c1sig_prof);

        //init child1 process 3 timer

        c1_realt.it_interval.tv_sec = 0;

        c1_realt.it_interval.tv_usec = 999999;

        c1_realt.it_value.tv_sec = 0;

        c1_realt.it_value.tv_usec = 999999;

        setitimer(ITIMER_REAL,&c1_realt,NULL);





        c1_virtt.it_interval.tv_sec = 0;

        c1_virtt.it_interval.tv_usec = 999999;

        c1_virtt.it_value.tv_sec = 0;

        c1_virtt.it_value.tv_usec = 999999;

        setitimer(ITIMER_VIRTUAL,&c1_virtt,NULL);



        c1_proft.it_interval.tv_sec = 0;

        c1_proft.it_interval.tv_usec = 999999;

        c1_proft.it_value.tv_sec = 0;

        c1_proft.it_value.tv_usec = 999999;

        setitimer(ITIMER_PROF,&c1_proft,NULL);

        //get fibonacci

        fib = fibonacci(atoi(argv[2]));

        //get child1 3 time and fibnacci

        printf("Child1 fib = %ld\n", fib);

        getitimer(ITIMER_REAL,&c1_realt);

        printf("Child1 Real Time = %ld Sec : %ld Msec\n", c1_real_secs + 9-c1_realt.it_value.tv_sec,(999999-c1_realt.it_value.tv_usec)/1000);

        getitimer(ITIMER_VIRTUAL,&c1_virtt);

        printf("Child1 Virtual Time = %ld Sec : %ld Msec\n",c1_virtual_secs + 9-c1_virtt.it_value.tv_sec,(999999-c1_virtt.it_value.tv_usec)/1000);

        getitimer(ITIMER_PROF,&c1_proft);

        printf("Child1 Prof Time = %ld Sec : %ld Msec\n",c1_prof_secs + 9-c1_proft.it_value.tv_sec,(999999-c1_proft.it_value.tv_usec)/1000);

        exit(0);

        }

        else if((pid2=fork()) == 0)

        {

        //bind signal and function for child2 process

        signal(SIGALRM,c2sig_real);

        signal(SIGVTALRM,c2sig_virtual);

        signal(SIGPROF,c2sig_prof);

        //init child2 process 3 timer

        c2_realt.it_interval.tv_sec = 9;

        c2_realt.it_interval.tv_usec = 999999;

        c2_realt.it_value.tv_sec = 9;

        c2_realt.it_value.tv_usec = 999999;

        setitimer(ITIMER_REAL,&c2_realt,NULL);





        c2_virtt.it_interval.tv_sec = 9;

        c2_virtt.it_interval.tv_usec = 999999;

        c2_virtt.it_value.tv_sec = 9;

        c2_virtt.it_value.tv_usec = 999999;

        setitimer(ITIMER_VIRTUAL,&c2_virtt,NULL);



        c2_proft.it_interval.tv_sec = 9;

        c2_proft.it_interval.tv_usec = 999999;

        c2_proft.it_value.tv_sec = 9;

        c2_proft.it_value.tv_usec = 999999;

        setitimer(ITIMER_PROF,&c2_proft,NULL);

        //get fibonacci

        fib = fibonacci(atoi(argv[3]));

        //get child2 3 time and fibnacci

        printf("Child2 fib = %ld\n", fib);

        getitimer(ITIMER_REAL,&c2_realt);

        printf("Child2 Real Time = %ld Sec : %ld Msec\n",c2_real_secs+9-c2_realt.it_value.tv_sec,(999999-c2_realt.it_value.tv_usec)/ 1000);

        getitimer(ITIMER_VIRTUAL,&c2_virtt);

        printf("Child2 Virtual Time = %ld Sec : %ld Msec\n",c2_virtual_secs+9-c2_virtt.it_value.tv_sec,(999999-c2_virtt.it_value.tv_usec)/1000);

        getitimer(ITIMER_PROF,&c2_proft);

        printf("Child2 Prof Time = %ld Sec : %ld Msec\n",c2_prof_secs+9-c2_proft.it_value.tv_sec,(999999-c2_proft.it_value.tv_usec)/ 1000);

        exit(0);

        }

        else

        {

        //get fibonacci

        fib = fibonacci(atoi(argv[4]));

        //print parent 3 time and fibnacci

        printf("Parent fib = %ld\n", fib);

        getitimer(ITIMER_REAL,&p_realt);

        printf("Parent Real Time = %ld Sec : %ld Msec\n",

               p_real_secs + 9 - p_realt.it_value.tv_sec,

               (999999 - p_realt.it_value.tv_usec) / 1000);

        getitimer(ITIMER_VIRTUAL,&p_virtt);

        printf("Parent Virtual Time = %ld Sec : %ld Msec\n",

               p_virtual_secs + 9 - p_virtt.it_value.tv_sec,

               (999999 - p_virtt.it_value.tv_usec) / 1000);

        getitimer(ITIMER_PROF,&p_proft);

        printf("Parent Prof Time = %ld Sec : %ld Msec\n",

               p_prof_secs + 9 - p_proft.it_value.tv_sec,

               (999999 - p_proft.it_value.tv_usec) / 1000);

        //wait child process

        waitpid(pid1,NULL,0);

        waitpid(pid2,NULL,0);

        }

    }

}



//parent process signal function

void psig_real(int signum)

{

    p_real_secs += 10;

}



void psig_virtual(int signum)

{

    p_virtual_secs += 10;

}



void psig_prof(int signum)

{

    p_prof_secs += 10;

}



//child1 process signal function

void c1sig_real(int signum)

{

    c1_real_secs += 10;

}



void c1sig_virtual(int signum)

{

    c1_virtual_secs += 10;

}



void c1sig_prof(int signum)

{

    c1_prof_secs += 10;

}



//child2 process signal function

void c2sig_real(int signum)

{

    c2_real_secs += 10;

}



void c2sig_virtual(int signum)

{

    c2_virtual_secs += 10;

}



void c2sig_prof(int signum)

{

    c2_prof_secs += 10;

}



//get fibonacci by n

long fibonacci(unsigned int n)

{

    if(n == 1 || n == 2)

        return 1;

    return fibonacci(n-1)+fibonacci(n-2);

}