Return to inetdgs.c CVS log

Up to [Net/2] / Net2 / tests / benchmarks / inet

Annotation of Net2/tests/benchmarks/inet/inetdgs.c, revision 1.1.1.1

1.1       root        1: #include <sys/types.h>
                      2: #include <sys/socket.h>
                      3: #include <sys/time.h>
                      4: #include <sys/resource.h>
                      5: #include <netinet/in.h>
                      6: 
                      7: #include <stdio.h>
                      8: #include <signal.h>
                      9: #include <setjmp.h>
                     10: #include <errno.h>
                     11: 
                     12: struct sockaddr_in sin;
                     13: jmp_buf        j;
                     14: int    catchsig();
                     15: 
                     16: main(argc, argv)
                     17:        char *argv[];
                     18: {
                     19:        int s, n;
                     20:        char buf[2 * BUFSIZ];
                     21:        struct rusage r1, r2;
                     22: 
                     23:        if (argc < 2) {
                     24:                printf("usage: %s port\n", argv[0]);
                     25:                exit(1);
                     26:        }
                     27:        s = socket(AF_INET, SOCK_DGRAM, 0);
                     28:        if (s < 0) {
                     29:                perror("inetdgs: socket");
                     30:                exit(1);
                     31:        }
                     32:        sin.sin_family = AF_INET;
                     33:        sin.sin_port = htons(atoi(argv[1]));
                     34:        if (bind(s, &sin, sizeof (sin)) < 0) {
                     35:                perror("inetdgs: bind");
                     36:                exit(1);
                     37:        }
                     38:        for (;;) {
                     39:                int count, ms, kb, fromlen;
                     40:                struct timeval t1, t2;
                     41:                struct sockaddr_in from;
                     42:                extern int errno;
                     43: 
                     44:                for (;;) {
                     45:                        fromlen = sizeof (from);
                     46:                        n = recvfrom(s, buf, sizeof (buf), 0, &from, &fromlen);
                     47:                        if (n < 0) {
                     48:                                if (errno != EINTR)
                     49:                                        perror("inetdgs: recvfrom");
                     50:                                continue;
                     51:                        }
                     52:                        if (strncmp(buf, "begin", 5) == 0)
                     53:                                break;
                     54:                }
                     55:                count = kb = 0;
                     56:                getrusage(RUSAGE_SELF, &r1);
                     57:                gettimeofday(&t1, (struct timezone *)0);
                     58:                for (;;) {
                     59:                        fromlen = sizeof (from);
                     60:                        n = recvfrom(s, buf, sizeof (buf), 0, &from, &fromlen);
                     61:                        if (n < 0) {
                     62:                                if (errno != EINTR)
                     63:                                        perror("inetdgs: recvfrom");
                     64:                                continue;
                     65:                        }
                     66:                        count++, kb += n;
                     67:                        if (strncmp(buf, "end", 3) == 0)
                     68:                                break;
                     69:                }
                     70:                gettimeofday(&t2, (struct timezone *)0);
                     71:                getrusage(RUSAGE_SELF, &r2);
                     72:                sleep(2);
                     73:                timevalsub(&t2, &t1);
                     74:                ms = t2.tv_usec / 1000;
                     75:                printf("%d msgs (%d bytes) in %d.%d secs", count,
                     76:                    kb, t2.tv_sec, ms / 100);
                     77:                printf(", %d bytes/msg, %6.2f kb/s, %4.1f ms/msg\n",
                     78:                    kb / count, (8. * kb) / (t2.tv_sec * 1024.),
                     79:                   (1000. * t2.tv_sec + ms) / count);
                     80:                timevalsub(&r2.ru_stime, &r1.ru_stime);
                     81:                timevalsub(&r2.ru_utime, &r1.ru_utime);
                     82:                r2.ru_nvcsw -= r1.ru_nvcsw;
                     83:                r2.ru_nivcsw -= r1.ru_nivcsw;
                     84:                printf("System %d.%d, user %d.%d, %d vcsw, %d ivcsw\n",
                     85:                    r2.ru_stime.tv_sec, r2.ru_stime.tv_usec / 100000,
                     86:                    r2.ru_utime.tv_sec, r2.ru_utime.tv_usec / 100000,
                     87:                    r2.ru_nvcsw, r2.ru_nivcsw);
                     88:        }
                     89: }
                     90: 
                     91: /*
                     92:  * Add and subtract routines for timevals.
                     93:  * N.B.: subtract routine doesn't deal with
                     94:  * results which are before the beginning,
                     95:  * it just gets very confused in this case.
                     96:  * Caveat emptor.
                     97:  */
                     98: timevaladd(t1, t2)
                     99:        struct timeval *t1, *t2;
                    100: {
                    101: 
                    102:        t1->tv_sec += t2->tv_sec;
                    103:        t1->tv_usec += t2->tv_usec;
                    104:        timevalfix(t1);
                    105: }
                    106: 
                    107: timevalsub(t1, t2)
                    108:        struct timeval *t1, *t2;
                    109: {
                    110: 
                    111:        t1->tv_sec -= t2->tv_sec;
                    112:        t1->tv_usec -= t2->tv_usec;
                    113:        timevalfix(t1);
                    114: }
                    115: 
                    116: timevalfix(t1)
                    117:        struct timeval *t1;
                    118: {
                    119: 
                    120:        if (t1->tv_usec < 0) {
                    121:                t1->tv_sec--;
                    122:                t1->tv_usec += 1000000;
                    123:        }
                    124:        if (t1->tv_usec >= 1000000) {
                    125:                t1->tv_sec++;
                    126:                t1->tv_usec -= 1000000;
                    127:        }
                    128: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.