fibtimer.c

一个主程序产生两个子进程计算N=36的Fibonacci数列

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

extern struct timeval tmReal,tmVirt,tmProf,t1Real,t1Virt,t1Prof,t2Real,t2Virt,t2Prof;
struct timeval tmReal,tmVirt,tmProf,t1Real,t1Virt,t1Prof,t2Real,t2Virt,t2Prof;

static void OnSignalMain(int sigNo)
{
	switch(sigNo)
	{
		case SIGALRM:
                        tmReal.tv_sec++;
			break;
		case SIGVTALRM:
                        tmVirt.tv_sec++;
			break;
		case SIGPROF:
                        tmProf.tv_sec++;
			break;
		default:
			break;
	}
}

static void OnSignal1(int sigNo)
{
	switch(sigNo)
	{
		case SIGALRM:
                        t1Real.tv_sec++;
			break;
		case SIGVTALRM:
                        t1Virt.tv_sec++;
			break;
		case SIGPROF:
                        t1Prof.tv_sec++;
			break;
		default:
			break;
	}
}

static void OnSignal2(int sigNo)
{
	switch(sigNo)
	{
		case SIGALRM:
                        t2Real.tv_sec++;
			break;
		case SIGVTALRM:
                        t2Virt.tv_sec++;
			break;
		case SIGPROF:
                        t2Prof.tv_sec++;
			break;
		default:
			break;
	}
}

unsigned long 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));
}

int main(int argc, char* argv[])
{
        unsigned long fib = 0;
        int pid1,pid2;
        unsigned int fibarg;
        int status;

        if (argc == 2)
        {
                fibarg = atoi(argv[1]);
        }
        else
        {
                printf("Invalid or missing arguments.\nUsage: fibtimer [integer number]\n");
                exit(1);
        }

        tmReal.tv_sec = 0;
        tmReal.tv_usec = 0;
        tmVirt.tv_sec = 0;
        tmVirt.tv_usec = 0;
        tmProf.tv_sec = 0;
        tmProf.tv_usec = 0;
        t1Real.tv_sec = 0;
        t1Real.tv_usec = 0;
        t1Virt.tv_sec = 0;
        t1Virt.tv_usec = 0;
        t1Prof.tv_sec = 0;
        t1Prof.tv_usec = 0;
        t2Real.tv_sec = 0;
        t2Real.tv_usec = 0;
        t2Virt.tv_sec = 0;
        t2Virt.tv_usec = 0;
        t2Prof.tv_sec = 0;
        t2Prof.tv_usec = 0;

        signal(SIGALRM, OnSignalMain);
	signal(SIGVTALRM, OnSignalMain);
	signal(SIGPROF, OnSignalMain);
        
	struct itimerval v;
	v.it_interval.tv_sec = 1;
	v.it_interval.tv_usec = 0;
	v.it_value.tv_sec = 1;
	v.it_value.tv_usec = 0;
	setitimer(ITIMER_REAL, &v, NULL);
        setitimer(ITIMER_PROF, &v, NULL);
        setitimer(ITIMER_VIRTUAL, &v, NULL);

	pid1 = fork();
        if (pid1 == 0)
        {
                struct itimerval v1Real,v1Prof,v1Virt;
                long ksec,kusec;
                signal(SIGALRM, OnSignal1);
             	signal(SIGVTALRM, OnSignal1);
            	signal(SIGPROF, OnSignal1);

           	setitimer(ITIMER_REAL, &v, NULL);
                setitimer(ITIMER_PROF, &v, NULL);
                setitimer(ITIMER_VIRTUAL, &v, NULL);

                fib = fibonacci(fibarg);

                getitimer(ITIMER_PROF, &v1Prof);
                getitimer(ITIMER_REAL, &v1Real);
                getitimer(ITIMER_VIRTUAL, &v1Virt);
                t1Real.tv_usec = 1000000 - v1Real.it_value.tv_usec;
                t1Prof.tv_usec = 1000000 - v1Prof.it_value.tv_usec;
                t1Virt.tv_usec = 1000000 - v1Virt.it_value.tv_usec;
                if (t1Prof.tv_usec >= t1Virt.tv_usec)
                {
                        ksec = t1Prof.tv_sec - t1Virt.tv_sec;
                        kusec = t1Prof.tv_usec - t1Virt.tv_usec;
                }
                else
                {
                        ksec = t1Prof.tv_sec - t1Virt.tv_sec - 1;
                        kusec = 1000000 - (t1Virt.tv_usec - t1Prof.tv_usec);
                }

                printf("\n");
                printf("Child 1 fib = %ld, real time = %ld sec, %ld msec\n", fib, t1Real.tv_sec, t1Real.tv_usec/1000);
                printf("Child 1 fib = %ld, cpu time = %ld sec, %ld msec\n", fib, t1Prof.tv_sec, t1Prof.tv_usec/1000);
                printf("Child 1 fib = %ld, user time = %ld sec, %ld msec\n", fib, t1Virt.tv_sec, t1Virt.tv_usec/1000);
                printf("Child 1 fib = %ld, kernel time = %ld sec, %ld msec\n", fib, ksec, kusec/1000);
                fflush(stdout);
                exit(0);
        }
        else
        {
                pid2 = fork();
                if (pid2 == 0)
                {
                        struct itimerval v2Real,v2Prof,v2Virt;
                        long ksec,kusec;
                        signal(SIGALRM, OnSignal2);
                      	signal(SIGVTALRM, OnSignal2);
                      	signal(SIGPROF, OnSignal2);

                       	setitimer(ITIMER_REAL, &v, NULL);
                        setitimer(ITIMER_PROF, &v, NULL);
                        setitimer(ITIMER_VIRTUAL, &v, NULL);

                        fib = fibonacci(fibarg);

                        getitimer(ITIMER_PROF, &v2Prof);
                        getitimer(ITIMER_REAL, &v2Real);
                        getitimer(ITIMER_VIRTUAL, &v2Virt);
                        t2Real.tv_usec = 1000000 - v2Real.it_value.tv_usec;
                        t2Prof.tv_usec = 1000000 - v2Prof.it_value.tv_usec;
                        t2Virt.tv_usec = 1000000 - v2Virt.it_value.tv_usec;
                        if (t2Prof.tv_usec >= t2Virt.tv_usec)
                        {
                                ksec = t2Prof.tv_sec - t2Virt.tv_sec;
                                kusec = t2Prof.tv_usec - t2Virt.tv_usec;
                        }
                        else
                        {
                                 ksec = t2Prof.tv_sec - t2Virt.tv_sec - 1;
                                 kusec = 1000000 - (t2Virt.tv_usec - t2Prof.tv_usec);
                        }

                        printf("\n");
                        printf("Child 2 fib = %ld, real time = %ld sec, %ld msec\n", fib, t2Real.tv_sec, t2Real.tv_usec/1000);
                        printf("Child 2 fib = %ld, cpu time = %ld sec, %ld msec\n", fib, t2Prof.tv_sec, t2Prof.tv_usec/1000);
                        printf("Child 2 fib = %ld, user time = %ld sec, %ld msec\n", fib, t2Virt.tv_sec, t2Virt.tv_usec/1000);
                        printf("Child 2 fib = %ld, kernel time = %ld sec, %ld msec\n", fib, ksec, kusec/1000);
                        fflush(stdout);
                        exit(0);
                }
                else
                {
                        struct itimerval vmReal,vmProf,vmVirt;
                        long ksec,kusec;

                        fib = fibonacci(fibarg);

                        waitpid(0, &status, 0);
                        waitpid(0, &status, 0);

                        getitimer(ITIMER_PROF, &vmProf);
                        getitimer(ITIMER_REAL, &vmReal);
                        getitimer(ITIMER_VIRTUAL, &vmVirt);
                        tmReal.tv_usec = 1000000 - vmReal.it_value.tv_usec;
                        tmProf.tv_usec = 1000000 - vmProf.it_value.tv_usec;
                        tmVirt.tv_usec = 1000000 - vmVirt.it_value.tv_usec;
                        if (tmProf.tv_usec >= tmVirt.tv_usec)
                        {
                                ksec = tmProf.tv_sec - tmVirt.tv_sec;
                                kusec = tmProf.tv_usec - tmVirt.tv_usec;
                        }
                        else
                        {
                                 ksec = tmProf.tv_sec - tmVirt.tv_sec - 1;
                                 kusec = 1000000 - (tmVirt.tv_usec - tmProf.tv_usec);
                        }

                        printf("\n");
                        printf("Parent fib = %ld, real time = %ld sec, %ld msec\n", fib, tmReal.tv_sec, tmReal.tv_usec/1000);
                        printf("Parent fib = %ld, cpu time = %ld sec, %ld msec\n", fib, tmProf.tv_sec, tmProf.tv_usec/1000);
                        printf("Parent fib = %ld, user time = %ld sec, %ld msec\n", fib, tmVirt.tv_sec, tmVirt.tv_usec/1000);
                        printf("Parent fib = %ld, kernel time = %ld sec, %ld msec\n", fib, ksec, kusec/1000);
                        fflush(stdout);
                }
        }

	return 0;
}