clock.c

clock的初学

#include <sys/time.h>
#include <signal.h>
#include <unistd.h>
#include <stdio.h>

long unsigned int fibonacci(unsigned int n);

static void p_sig_handler(int);
static void c1_sig_handler(int);
static void c2_sig_handler(int);

long elapsed_usecs(long a,long b);

static long p_realt_secs=0,c1_realt_secs=0,c2_realt_secs=0;
static long p_virtt_secs=0,c1_virtt_secs=0,c2_virtt_secs=0;
static long p_proft_secs=0,c1_proft_secs=0,c2_proft_secs=0;
static struct itimerval p_realt,c1_realt,c2_realt;
static struct itimerval p_virtt,c1_virtt,c2_virtt;
static struct itimerval p_proft,c1_proft,c2_proft;

main()
{
    long unsigned fib=0;
    int pid1,pid2,parent_pid;
    unsigned int fibarg1=41,fibarg2=38,fibarg3=43;
    int status;
    //father process
    p_realt.it_interval.tv_sec=0;
    p_realt.it_interval.tv_usec=999999;
    p_realt.it_value.tv_sec=0;
    p_realt.it_value.tv_usec=999999;
    
    p_virtt.it_interval.tv_sec=0;
    p_virtt.it_interval.tv_usec=999999;
    p_virtt.it_value.tv_sec=0;
    p_virtt.it_value.tv_usec=999999;

    p_proft.it_interval.tv_sec=0;
    p_proft.it_interval.tv_usec=999999;
    p_proft.it_value.tv_sec=0;
    p_proft.it_value.tv_usec=999999;
    //childe_1 process
    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;
                                                                                     
    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;
                                                                                     
    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;
    //child_2 process
    c2_realt.it_interval.tv_sec=0;
    c2_realt.it_interval.tv_usec=999999;
    c2_realt.it_value.tv_sec=0;
    c2_realt.it_value.tv_usec=999999;
                                                                                     
    c2_virtt.it_interval.tv_sec=0;
    c2_virtt.it_interval.tv_usec=999999;
    c2_virtt.it_value.tv_sec=0;
    c2_virtt.it_value.tv_usec=999999;
                                                                                     
    c2_proft.it_interval.tv_sec=0;
    c2_proft.it_interval.tv_usec=999999;
    c2_proft.it_value.tv_sec=0;
    c2_proft.it_value.tv_usec=999999;
    //start the father's signal program
    signal(SIGALRM,p_sig_handler);
    signal(SIGVTALRM,p_sig_handler);
    signal(SIGPROF,p_sig_handler);
    //set the father's itimers
    setitimer(ITIMER_REAL,&p_realt,NULL);
    setitimer(ITIMER_PROF,&p_proft,NULL);
    setitimer(ITIMER_VIRTUAL,&p_virtt,NULL);
    pid1=fork();
    if(pid1==0)
    {
       //start the child's signal program
       signal(SIGALRM,c1_sig_handler);
       signal(SIGVTALRM,c1_sig_handler);
       signal(SIGPROF,c1_sig_handler);
       //set the child's itimers
       setitimer(ITIMER_REAL,&c1_realt,NULL);
       setitimer(ITIMER_PROF,&c1_proft,NULL);
       setitimer(ITIMER_VIRTUAL,&c1_virtt,NULL);
    
    //execute the Fibonacce program
    fib=fibonacci(fibarg1);
    //get the itimer of child1 process
    getitimer(ITIMER_PROF,&c1_proft);
    getitimer(ITIMER_REAL,&c1_realt);
    getitimer(ITIMER_VIRTUAL,&c1_virtt);
    printf("\n");
    printf("Child 1 fib=%ld,real time=%ld sec,%ld msec\n",fib,c1_realt_secs, elapsed_usecs(c1_realt.it_value.tv_sec,c1_realt.it_value.tv_usec)/1000);
    printf("Child 1 fib=%ld,cpu time=%ld sec,%ld msec\n",fib,c1_proft_secs, elapsed_usecs(c1_proft.it_value.tv_sec,c1_proft.it_value.tv_usec)/1000);
    printf("Child 1 fib=%ld,user time=%ld sec,%ld msec\n",fib,c1_virtt_secs, elapsed_usecs(c1_virtt.it_value.tv_sec,c1_virtt.it_value.tv_usec)/1000);
    printf("Child 1 fib=%ld,kernel time=%ld sec,%ld msec\n",fib,c1_proft_secs-c1_virtt_secs, (elapsed_usecs(c1_proft.it_value.tv_sec,c1_proft.it_value.tv_usec)/1000-elapsed_usecs(c1_virtt.it_value.tv_sec,c1_virtt.it_value.tv_usec)/1000));
    fflush(stdout);
    exit(0);
  }
   else
  {
     pid2=fork();
     if(pid2==0) 
     {
         //start the child2's signal program
       signal(SIGALRM,c2_sig_handler);
       signal(SIGVTALRM,c2_sig_handler);
       signal(SIGPROF,c2_sig_handler);
       //set the child2's itimers
       setitimer(ITIMER_REAL,&c2_realt,NULL);
       setitimer(ITIMER_PROF,&c2_proft,NULL);
       setitimer(ITIMER_VIRTUAL,&c2_virtt,NULL);
                                                                                       
    //execute the Fibonacce program
    fib=fibonacci(fibarg2);
    //get the itimer of child2 process
    getitimer(ITIMER_PROF,&c2_proft);
    getitimer(ITIMER_REAL,&c2_realt);
    getitimer(ITIMER_VIRTUAL,&c2_virtt);
    printf("\n");
    printf("Child 2 fib=%ld,real time=%ld sec,%ld msec\n",fib,c2_realt_secs, elapsed_usecs(c2_realt.it_value.tv_sec,c2_realt.it_value.tv_usec)/1000);
    printf("Child 2 fib=%ld,cpu time=%ld sec,%ld msec\n",fib,c2_proft_secs, elapsed_usecs(c2_proft.it_value.tv_sec,c2_proft.it_value.tv_usec)/1000);
    printf("Child 2 fib=%ld,user time=%ld sec,%ld msec\n",fib,c2_virtt_secs, elapsed_usecs(c2_virtt.it_value.tv_sec,c2_virtt.it_value.tv_usec)/1000);
    printf("Child 2 fib=%ld,kernel time=%ld sec,%ld msec\n",fib,c2_proft_secs-c2_virtt_secs, (elapsed_usecs(c2_proft.it_value.tv_sec,c2_proft.it_value.tv_usec)/1000-elapsed_usecs(c2_virtt.it_value.tv_sec,c2_virtt.it_value.tv_usec)/1000));
    fflush(stdout);
    exit(0);
    }
    //father's time
    else
    {
       // father excecute the fibonacci
       fib=fibonacci(fibarg3);
       //wait for the child process
       waitpid(0,&status,0);
       waitpid(0,&status,0);
       //get the father's time
       getitimer(ITIMER_PROF,&p_proft);
    getitimer(ITIMER_REAL,&p_realt);
    getitimer(ITIMER_VIRTUAL,&p_virtt);
    printf("\n");
    printf("father fib=%ld,real time=%ld sec,%ld msec\n",fib,p_realt_secs, elapsed_usecs(p_realt.it_value.tv_sec,p_realt.it_value.tv_usec)/1000);
    printf("father fib=%ld,cpu time=%ld sec,%ld msec\n",fib,p_proft_secs, elapsed_usecs(p_proft.it_value.tv_sec,p_proft.it_value.tv_usec)/1000);
    printf("father fib=%ld,user time=%ld sec,%ld msec\n",fib,p_virtt_secs, elapsed_usecs(p_virtt.it_value.tv_sec,p_virtt.it_value.tv_usec)/1000);
    printf("father fib=%ld,kernel time=%ld sec,%ld msec\n",fib,p_proft_secs-p_virtt_secs, (elapsed_usecs(p_proft.it_value.tv_sec,p_proft.it_value.tv_usec)/1000-elapsed_usecs(p_virtt.it_value.tv_sec,p_virtt.it_value.tv_usec)/1000));
    fflush(stdout);
    exit(0);

    }
    printf("this line should never be printed\n");
  }

}
long unsigned int fibonacci(unsigned int n)
{
   if(n==0)
     return 0;
   else if (n==1||n==2)
     return 1;
   else
     return (fibonacci(n-1)+fibonacci(n-2));
}
static void p_sig_handler(int signo)
{
   switch(signo)
   {
      case SIGALRM:
         p_realt_secs++;
         break;
      case SIGVTALRM:
         p_virtt_secs++;
         break;
      case SIGPROF:
         p_proft_secs++;
         break;
   }
}
static void c1_sig_handler(int signo)
{
   switch(signo)
   {
      case SIGALRM:
         c1_realt_secs++;
         break;
      case SIGVTALRM:
         c1_virtt_secs++;
         break;
      case SIGPROF:
         c1_proft_secs++;
         break;
   }
}
static void c2_sig_handler(int signo)
{
   switch(signo)
   {
      case SIGALRM:
         c2_realt_secs++;
         break;
      case SIGVTALRM:
         c2_virtt_secs++;
         break;
      case SIGPROF:
         c2_proft_secs++;
         break;
   }
}
long elapsed_usecs(long a,long b)
{
   return 999999-b;
}