[LUGA] Mit freundlicher Unterstützung von:
WSR

Mail Thread Index


[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

2.0 und ein dummer fork-Benchmark



2.0 scheint großteils zu funktionieren, aber:

Ich kann meinen alten PC nicht mehr über Ethernet erreichen. Derzeit
weiß ich noch nicht, an welchem PC das liegt (Der alte könnte mir
die Entführung von /usr übelnehmen :-) ).

tcpdump stürzt nach dem ersten Paket ab.

Alle Prozesse brauchen entweder 0 oder 55612.6% Memory (und ich offenbar
schon wieder ein neues procps).

Dafür schaut das Ergebnis meines dauerfork-Benchmarks recht
beeindruckend aus:

max outstanding: 217, avg outstanding: 135.278
failed forks: 0
176.422s real  171.180s user  177.140s system  197% ./forker -p 1000 -w
10000000

Zum Vergleich die wsrdb:

max outstanding: 74, avg outstanding: 59.05
failed forks: 0
232.508s real  211.140s user  6.060s system  93% ./forker -p 1000 -w
10000000

Allerdings muß man zugeben, daß die wsrdb während des Runs auch 
etwas responsiver war :-)

--8<----8<----8<----8<----8<----8<----8<----8<----8<----8<--
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>

char *cmnd;

void usage(void) {
        fprintf(stderr, "Usage: %s -p maxproc -w maxwork\n", cmnd);
        exit(1);
}


int main(int argc, char **argv) {
        int i;
        int max_proc = 10;
        int max_work = 0;
        struct {
                int type;
                int pid;
                int outstanding;
        } *event;
        int ec = 0;
        int pid;
        int outstanding = 0;
        int c;
        int max_outstanding = 0;
        int sum_outstanding = 0;
        int failed_forks = 0;

        while ((c = getopt(argc, argv, "p:w:")) != EOF) {
                switch (c) {
                        char *p;
                case 'p':
                        max_proc = strtol(optarg, &p, 0);
                        if (p == optarg || *p) usage();
                        break;
                case 'w':
                        max_work = strtol(optarg, &p, 0);
                        if (p == optarg || *p) usage();
                        break;
                case '?':
                        usage();
                default:
                        assert(0);
                }

        }
        event = malloc(max_proc * 2 * sizeof(*event));
        if (!event) {
                fprintf(stderr,
                        "%s: cannot malloc event log: %s\n",
                        argv[0], strerror(errno));
                exit(1);
        }

        for (i = 0; i < max_proc; i++) {
                switch (pid = fork()) {
                case -1:
                        assert(ec < 2*max_proc);
                        event[ec].type = 0;
                        event[ec].pid = pid;
                        event[ec].outstanding = outstanding;
                        ec++;
                        break;
                case 0:
                        for (i = 0; i < max_work; i++) ;
                        exit(0);
                        break;
                default:
                        outstanding++;
                        assert(ec < 2*max_proc);
                        event[ec].type = 0;
                        event[ec].pid = pid;
                        event[ec].outstanding = outstanding;
                        ec++;
                        while ((pid = wait3(NULL, WNOHANG, NULL)) > 0) {
                                outstanding--;
                                assert(ec < 2*max_proc);
                                event[ec].type = 1;
                                event[ec].pid = pid;
                                event[ec].outstanding = outstanding;
                                ec++;
                        }
                }
        }
        while ((pid = wait3(NULL, 0, NULL)) > 0) {
                outstanding--;
                assert(ec < 2*max_proc);
                event[ec].type = 1;
                event[ec].pid = pid;
                event[ec].outstanding = outstanding;
                ec++;
        }
        for (i = 0; i < ec; i++) {
                printf("%d: %s %d (%d outstanding)\n",
                        i,
                        event[i].type ? "exit" : "fork",
                        event[i].pid,
                        event[i].outstanding);
                if (event[i].outstanding > max_outstanding) {
                        max_outstanding = event[i].outstanding;
                }
                sum_outstanding += event[i].outstanding;
                if (event[i].type == 0 && event[i].pid == -1) {
                        failed_forks ++;
                }
        }
        printf ("\n");
        printf ("max outstanding: %d, avg outstanding: %g\n",
                max_outstanding, (double)sum_outstanding / ec);
        printf ("failed forks: %d\n", failed_forks);
        exit(0);
}

                                

--8<----8<----8<----8<----8<----8<----8<----8<----8<----8<--
        hp

-- 
   _  | Peter J. Holzer             | Workstations are like toothbrushes --
|_|_) | Sysadmin WSR                | Nobody may use mine, especially not
| |   | hjp@wsr.ac.at               | while I am using it.
__/   | http://wsrx.wsr.ac.at/~hjp/ |     -- Robert van Renesse



powered by LINUX the choice of a gnu generation
linux user group austria;
Suche
Suche
Letzte Änderung:
webmaster@luga.at
September 2010