int main(int ac, char **av) { int i; int c; int parallel = 1; int warmup = 0; int repetitions = TRIES; size_t len; size_t range; size_t stride; char *usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] [-t] len [stride...]\n"; while (( c = getopt(ac, av, "tP:W:N:")) != EOF) { switch(c) { case 't': fpInit = thrash_initialize; break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind == ac) { lmbench_usage(ac, av, usage); } len = atoi(av[optind]); len *= 1024 * 1024; if (optind == ac - 1) { fprintf(stderr, "\"stride=%d\n", (int)STRIDE); for (range = LOWER; range <= len; range = step(range)) { loads(len, range, STRIDE, parallel, warmup, repetitions); } } else { for (i = optind + 1; i < ac; ++i) { stride = bytes(av[i]); fprintf(stderr, "\"stride=%d\n", (int)stride); for (range = LOWER; range <= len; range = step(range)) { loads(len, range, stride, parallel, warmup, repetitions); } fprintf(stderr, "\n"); } } return(0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = TRIES; char *usage = "-s\n OR [-P <parallelism>] [-W <warmup>] [-N <repetitions>]\n OR -S\n"; int c; /* Start the server "-s" or Shut down the server "-S" */ if (ac == 2) { if (!strcmp(av[1], "-s")) { #ifdef CONFIG_NOMMU if (fork() == 0) { server_main(); _exit(0); } #else if (fork() == 0) { server_main(); } #endif exit(0); } if (!strcmp(av[1], "-S")) { int sock = unix_connect(CONNAME); write(sock, "0", 1); close(sock); exit(0); } } /* * Rest is client */ while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac) { lmbench_usage(ac, av, usage); } benchmp(NULL, benchmark, NULL, 0, parallel, warmup, repetitions, NULL); micro("UNIX connection cost", get_n()); }
int main(int argc, char *argv[]) { struct _state state; int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; char* usage = "[-m <message size>] [-M <total bytes>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>]\n"; state.xfer = XFERSIZE; /* per-packet size */ state.bytes = XFER; /* total bytes per call */ while (( c = getopt(argc,argv,"m:M:P:W:N:")) != EOF) { switch(c) { case 'm': state.xfer = bytes(optarg); break; case 'M': state.bytes = bytes(optarg); break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(argc, argv, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(argc, argv); break; } } if (optind == argc - 1) { state.bytes = bytes(argv[optind]); } else if (optind < argc - 1) { lmbench_usage(argc, argv); } state.pid = 0; /* round up total byte count to a multiple of xfer */ if (state.bytes % state.xfer) { state.bytes += state.bytes - state.bytes % state.xfer; } benchmp(initialize, reader, cleanup, MEDIUM, parallel, warmup, repetitions, &state); if (gettime() > 0) { fprintf(stderr, "AF_UNIX sock stream bandwidth: "); mb(get_n() * parallel * XFER); } return(0); }
int main(int ac, char **av) { int i; int parallel = 1; int warmup = 0; int repetitions = TRIES; static int sizes[] = { 0, 1024, 4096, 10*1024 }; struct _state state; int c; char* usage = "[-s <file size>] [-n <max files per dir>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] [<dir>]\n"; state.size = 0; state.max = 100; state.tmpdir = NULL; while (( c = getopt(ac, av, "s:n:P:W:N:")) != EOF) { switch(c) { case 's': state.size = bytes(optarg); break; case 'n': state.max = bytes(optarg); break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac - 1) { lmbench_usage(ac, av, usage); } if (optind == ac - 1) { state.tmpdir = av[1]; } if (state.size) { measure(state.size, parallel, warmup, repetitions, &state); } else { for (i = 0; i < sizeof(sizes)/sizeof(int); ++i) { state.size = sizes[i]; measure(state.size, parallel, warmup, repetitions, &state); } } return(0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = -1; int c; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] procedure|fork|exec|shell\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind + 1 != ac) { /* should have one argument left */ lmbench_usage(ac, av, usage); } if (!strcmp("procedure", av[optind])) { benchmp(NULL, do_procedure, cleanup, 0, parallel, warmup, repetitions, &ac); micro("Procedure call", get_n()); } else if (!strcmp("fork", av[optind])) { benchmp(NULL, do_fork, cleanup, 0, parallel, warmup, repetitions, NULL); micro(STATIC_PREFIX "Process fork+exit", get_n()); } else if (!strcmp("exec", av[optind])) { benchmp(NULL, do_forkexec, cleanup, 0, parallel, warmup, repetitions, NULL); micro(STATIC_PREFIX "Process fork+execve", get_n()); } else if (!strcmp("shell", av[optind])) { benchmp(NULL, do_shell, cleanup, 0, parallel, warmup, repetitions, NULL); micro(STATIC_PREFIX "Process fork+/bin/sh -c", get_n()); } else { lmbench_usage(ac, av, usage); } return(0); }
int main(int ac, char **av) { state_t state; int rc, c, repetitions = -1, warmup = 0; char buf[256]; char *usage = "-s\n OR [-S] [-W <warmup>] [-N <repetitions>] server\n"; while (( c = getopt(ac, av, "sSP:W:N:")) != EOF) { switch(c) { case 's': /* Server */ if (fork() == 0) { server_main(); } exit(0); case 'S': /* shutdown serverhost */ { int sock = tcp_connect(av[optind], TCP_CONNECT, SOCKOPT_NONE); rc = write(sock, "0", 1); if (rc < 0) DIE_PERROR("write failed"); close(sock); exit(0); } case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind + 1 != ac) { lmbench_usage(ac, av, usage); } handle_scheduler(benchmp_childid(), 0, 0); state.server = av[optind]; benchmp(NULL, doclient, NULL, 0, 1, warmup, repetitions, &state); sprintf(buf, "TCP/IP connection cost to %s", state.server); micro(buf, get_n()); exit(0); }
int main(int ac, char **av) { state_t state; int parallel = 1; int warmup = 0; int repetitions = -1; int c; double time; uint64 usecs; char buf[1024]; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] Njobs usecs...\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (ac < optind + 2) { lmbench_usage(ac, av, usage); } state.jobs = atoi(av[optind]); state.pids = NULL; fprintf(stderr, "\"pmake jobs=%d\n", state.jobs); while (++optind < ac) { usecs = bytes(av[optind]); benchmp(setup, work, NULL, 0, 1, 0, TRIES, &state); if (gettime() == 0) exit(1); state.iterations = (iter_t)((usecs * get_n()) / gettime()); benchmp(setup, bench, NULL, 0, parallel, warmup, repetitions, &state); time = gettime(); time /= get_n(); if (time > 0.0) fprintf(stderr, "%llu %.2f\n", usecs, time); } return (0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>]\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac) { lmbench_usage(ac, av, usage); } #ifdef HAVE_DRAND48 benchmp(NULL, bench_drand48, NULL, 0, parallel, warmup, repetitions, NULL); nano("drand48 latency", get_n()); benchmp(NULL, bench_lrand48, NULL, 0, parallel, warmup, repetitions, NULL); nano("lrand48 latency", get_n()); #endif #ifdef HAVE_RAND benchmp(NULL, bench_rand, NULL, 0, parallel, warmup, repetitions, NULL); nano("rand latency", get_n()); #endif #ifdef HAVE_RANDOM benchmp(NULL, bench_random, NULL, 0, parallel, warmup, repetitions, NULL); nano("random latency", get_n()); #endif return (0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] install|catch|prot [file]\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1 && optind != ac - 2) { lmbench_usage(ac, av, usage); } if (!strcmp("install", av[optind])) { benchmp(NULL, do_install, NULL, 0, parallel, warmup, repetitions, NULL); micro("Signal handler installation", get_n()); } else if (!strcmp("catch", av[optind])) { bench_catch(parallel, warmup, repetitions); micro("Signal handler overhead", get_n()); } else if (!strcmp("prot", av[optind]) && optind == ac - 2) { bench_prot(av[optind+1], parallel, warmup, repetitions); micro("Protection fault", get_n()); } else { lmbench_usage(ac, av, usage); } return(0); }
int main(int ac, char **av) { int c; int i; int parallel = 1; int warmup = 0; int repetitions = TRIES; char buf[1024]; state_t state; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] cmdline...\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind >= ac) { lmbench_usage(ac, av, usage); } state.argv = (char**)malloc((ac - optind + 1) * sizeof(char*)); state.pid = 0; for (i = 0; i < ac - optind; ++i) { state.argv[i] = av[optind + i]; } state.argv[i] = NULL; benchmp(NULL, bench, NULL, 0, parallel, warmup, repetitions, &state); micro("lat_cmd", get_n()); return (0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = -1; struct _state state; int c; char* usage = "[-m <message size>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>]\n"; state.msize = 1; state.pid = 0; while (( c = getopt(ac, av, "m:P:W:N:")) != EOF) { switch(c) { case 'm': state.msize = atoi(optarg); break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac) { lmbench_usage(ac, av, usage); } benchmp(initialize, benchmark, cleanup, 0, parallel, warmup, repetitions, &state); micro("AF_UNIX sock stream latency", get_n()); return(0); }
/* * Assumptions: * * 1) Cache lines are a multiple of pointer-size words * 2) Cache lines are no larger than 1/8 of a page (typically 512 bytes) * 3) Pages are an even multiple of cache lines */ int main(int ac, char **av) { int i; int c; int warmup = 0; int repetitions = TRIES; int print_cost = 0; size_t len; size_t maxlen = 64 * 1024 * 1024; double par; struct mem_state state; char *usage = "[-c] [-L <line size>] [-M len[K|M]] [-W <warmup>] [-N <repetitions>]\n"; state.line = getpagesize() / 16; state.pagesize = getpagesize(); while (( c = getopt(ac, av, "cL:M:W:N:")) != EOF) { switch(c) { case 'c': print_cost = 1; break; case 'L': state.line = atoi(optarg); if (state.line < sizeof(char*)) state.line = sizeof(char*); break; case 'M': maxlen = bytes(optarg); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } for (i = MAX_MEM_PARALLELISM * state.line; i <= maxlen; i<<=1) { par = par_mem(i, warmup, repetitions, &state); if (par > 0.) { fprintf(stderr, "%.6f %.2f\n", i / (1000. * 1000.), par); } } exit(0); }
int main(int ac, char **av) { state_t state; int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>]\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac) { lmbench_usage(ac, av, usage); } state.pid = 0; benchmp(initialize, doit, cleanup, SHORT, parallel, warmup, repetitions, &state); micro("Pipe latency", get_n()); return (0); }
int main(int ac, char **av) { int maxlen = 64 * 1024 * 1024; int warmup = 0; int repetitions = -1; int c; struct dram_page_state state; double dram_hit, dram_miss; char *usage = "[-v] [-W <warmup>] [-N <repetitions>][-M len[K|M]]\n"; state.mstate.width = 1; state.mstate.line = sizeof(char*); state.mstate.pagesize = getpagesize(); state.group = 16; while (( c = getopt(ac, av, "aL:T:M:W:N:")) != EOF) { switch(c) { case 'L': state.mstate.line = bytes(optarg); break; case 'T': state.group = bytes(optarg); break; case 'M': maxlen = bytes(optarg); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } dram_hit = loads(mem_initialize, maxlen, warmup, repetitions, &state); dram_miss = loads(dram_page_initialize, maxlen, warmup, repetitions, &state); if (dram_hit < 0.95 * dram_miss) { fprintf(stderr, "%f\n", dram_miss - dram_hit); } else { fprintf(stderr, "0.0\n"); } return (0); }
/* * Assumptions: * * 1) Cache lines are a multiple of pointer-size words * 2) Cache lines are no larger than 1/4 a page size * 3) Pages are an even multiple of cache lines */ int main(int ac, char **av) { int i, j, l; int verbose = 0; int warmup = 0; int repetitions = TRIES; int c; size_t maxlen = 64 * 1024 * 1024; struct mem_state state; char *usage = "[-v] [-W <warmup>] [-N <repetitions>][-M len[K|M]]\n"; state.line = sizeof(char*); state.pagesize = getpagesize(); while (( c = getopt(ac, av, "avM:W:N:")) != EOF) { switch(c) { case 'v': verbose = 1; break; case 'M': maxlen = bytes(optarg); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if ((l = line_find(maxlen, warmup, repetitions, &state)) > 0) { if (verbose) { printf("cache line size: %d bytes\n", l); } else { printf("%d\n", l); } } return (0); }
int main(int ac, char **av) { state_t state; int parallel = 1; int warmup = 0; int repetitions = -1; int c; char* usage = "[-n <#descriptors>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] file|tcp\n"; char buf[256]; morefds(); /* bump fd_cur to fd_max */ state.num = 200; while (( c = getopt(ac, av, "P:W:N:n:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; case 'n': state.num = bytes(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind + 1 != ac) { lmbench_usage(ac, av, usage); } if (streq("tcp", av[optind])) { state.fid_f = open_socket; server(&state); benchmp(initialize, doit, cleanup, 0, parallel, warmup, repetitions, &state); sprintf(buf, "Select on %d tcp fd's", state.num); kill(state.pid, SIGKILL); waitpid(state.pid, NULL, 0); micro(buf, get_n()); } else if (streq("file", av[optind])) { state.fid_f = open_file; server(&state); benchmp(initialize, doit, cleanup, 0, parallel, warmup, repetitions, &state); unlink(state.fname); sprintf(buf, "Select on %d fd's", state.num); micro(buf, get_n()); } else { lmbench_usage(ac, av, usage); } exit(0); }
int main(int ac, char **av) { int i, maxprocs; int c; int parallel = 1; int warmup = 0; int repetitions = -1; struct _state state; char *usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] [-s kbytes] processes [processes ...]\n"; double time; /* * Need 4 byte ints. */ if (sizeof(int) != 4) { fprintf(stderr, "Fix sumit() in ctx.c.\n"); exit(1); } state.process_size = 0; state.overhead = 0.0; state.pids = NULL; /* * If they specified a context size, or parallelism level, get them. */ while (( c = getopt(ac, av, "s:P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; case 's': state.process_size = atoi(optarg) * 1024; break; default: lmbench_usage(ac, av, usage); break; } } if (optind > ac - 1) lmbench_usage(ac, av, usage); /* compute pipe + sumit overhead */ maxprocs = atoi(av[optind]); for (i = optind; i < ac; ++i) { state.procs = atoi(av[i]); if (state.procs > maxprocs) maxprocs = state.procs; } state.procs = maxprocs; benchmp(initialize_overhead, benchmark_overhead, cleanup_overhead, 0, 1, warmup, repetitions, &state); if (gettime() == 0) return(0); state.overhead = gettime(); state.overhead /= get_n(); fprintf(stderr, "\n\"size=%dk ovr=%.2f\n", state.process_size/1024, state.overhead); /* compute the context switch cost for N processes */ for (i = optind; i < ac; ++i) { state.procs = atoi(av[i]); benchmp(initialize, benchmark, cleanup, 0, parallel, warmup, repetitions, &state); time = gettime(); time /= get_n(); time /= state.procs; time -= state.overhead; if (time > 0.0) fprintf(stderr, "%d %.2f\n", state.procs, time); } return (0); }
int main(int ac, char **av) { int parallel = 1; int warmup = LONGER; int repetitions = -1; int shutdown = 0; state_t state; char *usage = "-s\n OR [-m <message size>] [-M <bytes to move>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] server\n OR -S serverhost\n"; int c; state.msize = 0; state.move = 0; /* Rest is client argument processing */ while (( c = getopt(ac, av, "sS:m:M:P:W:N:")) != EOF) { switch(c) { case 's': /* Server */ if (fork() == 0) { server_main(); } exit(0); break; case 'S': /* shutdown serverhost */ { int conn; conn = tcp_connect(optarg, TCP_DATA, SOCKOPT_NONE); write(conn, "0", 1); exit(0); } case 'm': state.msize = bytes(optarg); break; case 'M': state.move = bytes(optarg); break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac - 2 || optind >= ac) { lmbench_usage(ac, av, usage); } state.server = av[optind++]; if (state.msize == 0 && state.move == 0) { state.msize = state.move = XFERSIZE; } else if (state.msize == 0) { state.msize = state.move; } else if (state.move == 0) { state.move = state.msize; } /* make the number of bytes to move a multiple of the message size */ if (state.move % state.msize) { state.move += state.msize - state.move % state.msize; } /* * Default is to warmup the connection for seven seconds, * then measure performance over each timing interval. * This minimizes the effect of opening and initializing TCP * connections. */ benchmp(initialize, loop_transfer, cleanup, 0, parallel, warmup, repetitions, &state); if (gettime() > 0) { fprintf(stderr, "%.6f ", state.msize / (1000. * 1000.)); mb(state.move * get_n() * parallel); } return(0); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = -1; int server = 0; state_t state; char *usage = "-s\n OR [-m <message size>] [-W <warmup>] [-N <repetitions>] server [size]\n OR -S serverhost\n"; int c; uint64 usecs; state.msize = 0; state.move = 10*1024*1024; /* Rest is client argument processing */ while (( c = getopt(ac, av, "sS:m:W:N:")) != EOF) { switch(c) { case 's': /* Server */ #ifdef CONFIG_NOMMU if (vfork() == 0) { server_main(); _exit(0); } #else if (fork() == 0) { server_main(); } #endif exit(0); case 'S': /* shutdown serverhost */ { int seq, n; int sock = udp_connect(optarg, UDP_XACT, SOCKOPT_NONE); for (n = -1; n > -5; --n) { seq = htonl(n); (void) send(sock, &seq, sizeof(int), 0); } close(sock); exit (0); } case 'm': state.msize = atoi(optarg); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind < ac - 2 || optind >= ac) { lmbench_usage(ac, av, usage); } state.server = av[optind++]; if (optind < ac) { state.move = bytes(av[optind]); } if (state.msize == 0) { state.msize = state.move; } /* make the number of bytes to move a multiple of the message size */ if (state.move % state.msize) { state.move += state.move - state.move % state.msize; } state.buf = valloc(state.msize); if (!state.buf) { perror("valloc"); exit(1); } touch(state.buf, state.msize); /* * Make one run take at least 5 seconds. * This minimizes the effect of connect & reopening TCP windows. */ benchmp(init, loop_transfer, cleanup, LONGER, parallel, warmup, repetitions, &state ); out: (void)fprintf(stderr, "socket UDP bandwidth using %s: ", state.server); mb(state.move * get_n() * parallel); }
int main(int ac, char **av) { int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; struct _state state; char* usage = "[-P <parallelism>] [-W <warmup>] [-N <repetitions>] null|read|write|stat|fstat|open [file]\n"; while (( c = getopt(ac, av, "P:W:N:")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1 && optind != ac - 2 ) { lmbench_usage(ac, av, usage); } state.file = FNAME; if (optind == ac - 2) state.file = av[optind + 1]; if (!strcmp("null", av[optind])) { benchmp(NULL, do_getppid, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple syscall", get_n()); } else if (!strcmp("write", av[optind])) { state.fd = open("/dev/null", 1); benchmp(NULL, do_write, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple write", get_n()); close(state.fd); } else if (!strcmp("read", av[optind])) { state.fd = open("/dev/zero", 0); if (state.fd == -1) { fprintf(stderr, "Simple read: -1\n"); return(1); } benchmp(NULL, do_read, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple read", get_n()); close(state.fd); } else if (!strcmp("stat", av[optind])) { benchmp(NULL, do_stat, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple stat", get_n()); } else if (!strcmp("fstat", av[optind])) { state.fd = open(state.file, 0); benchmp(NULL, do_fstat, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple fstat", get_n()); close(state.fd); } else if (!strcmp("open", av[optind])) { benchmp(NULL, do_openclose, NULL, 0, parallel, warmup, repetitions, &state); micro("Simple open/close", get_n()); } else { lmbench_usage(ac, av, usage); } return(0); }
int main(int ac, char **av) { int fd; state_t state; int parallel = 1; int warmup = 0; int repetitions = -1; int c; char usage[1024]; sprintf(usage,"[-C] [-P <parallelism>] [-W <warmup>] [-N <repetitions>]" " [-D <path>] [-I isolate_paths ] [-U uid/gid] \n" " [-L <lock_uid>] [-w <open for write>] <filename>\n"); state.clone = 0; state.write = 1; state.lock_uid = 0; while (( c = getopt(ac, av, "P:W:N:L:D:CIUw")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; case 'L': state.lock_uid = atoi(optarg); break; case 'D': strcpy(state.path, optarg); break; case 'C': state.clone = 1; break; case 'I': state.isolate = 1; break; case 'U': state.use_uid = 1; break; case 'w': state.write = 1; break; default: lmbench_usage(ac, av, usage); break; } } if (optind + 1 != ac) { /* should have three arguments left */ lmbench_usage(ac, av, usage); } strcpy(state.filename,av[optind]); benchmp(initialize, time_with_loop, cleanup, 0, parallel, warmup, repetitions, &state); mili_op("res ", get_n(), parallel); return (0); }
int main(int ac, char **av) { state_t state; int parallel = 1; int warmup = 0; int repetitions = TRIES; int c; char buf[256]; char *usage = "-s\n OR [-m <message size>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] server\n OR -S server\n"; state.msize = 1; while (( c = getopt(ac, av, "sS:m:P:W:N:")) != EOF) { switch(c) { case 's': /* Server */ #ifdef CONFIG_NOMMU server_main(); #else if (fork() == 0) { server_main(); } #endif exit(0); case 'S': /* shutdown serverhost */ state.sock = tcp_connect(optarg, TCP_XACT, SOCKOPT_NONE); close(state.sock); exit(0); case 'm': state.msize = atoi(optarg); break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1) { lmbench_usage(ac, av, usage); } state.server = av[optind]; benchmp(init, doclient, cleanup, MEDIUM, parallel, warmup, repetitions, &state); sprintf(buf, "TCP latency using %s", state.server); micro(buf, get_n()); exit(0); }
int main(int ac, char **av) { int realtime = 0; int parallel = 1; int warmup = 0; int repetitions = -1; int c; char buf[512]; timer_e what = USLEEP; state_t state; char *scheduler = ""; char *mechanism = "usleep"; char *usage = "[-r] [-u <method>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] usecs\nmethod=usleep|nanosleep|select|pselect|itimer\n"; realtime = 0; while ((c = getopt(ac, av, "ru:W:N:")) != EOF) { switch (c) { case 'r': realtime = 1; break; case 'u': if (strcmp(optarg, "usleep") == 0) { what = USLEEP; mechanism = "usleep"; } else if (strcmp(optarg, "nanosleep") == 0) { what = NANOSLEEP; mechanism = "nanosleep"; } else if (strcmp(optarg, "select") == 0) { what = SELECT; mechanism = "select"; #ifdef _POSIX_SELECT } else if (strcmp(optarg, "pselect") == 0) { what = PSELECT; mechanism = "pselect"; #endif /* _POSIX_SELECT */ } else if (strcmp(optarg, "itimer") == 0) { what = ITIMER; mechanism = "itimer"; } else { lmbench_usage(ac, av, usage); } break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1) { lmbench_usage(ac, av, usage); } state.usecs = bytes(av[optind]); if (realtime && set_realtime()) scheduler = "realtime "; switch (what) { case USLEEP: benchmp(NULL, bench_usleep, NULL, 0, parallel, warmup, repetitions, &state); break; case NANOSLEEP: benchmp(NULL, bench_nanosleep, NULL, 0, parallel, warmup, repetitions, &state); break; case SELECT: benchmp(NULL, bench_select, NULL, 0, parallel, warmup, repetitions, &state); break; #ifdef _POSIX_SELECT case PSELECT: benchmp(NULL, bench_pselect, NULL, 0, parallel, warmup, repetitions, &state); break; #endif /* _POSIX_SELECT */ case ITIMER: benchmp(initialize, bench_itimer, NULL, 0, parallel, warmup, repetitions, &state); break; default: lmbench_usage(ac, av, usage); break; } sprintf(buf, "%s%s %lu microseconds", scheduler, mechanism, state.usecs); micro(buf, get_n()); return (0); }
int main(int ac, char **av) { state_t state; int c; int parallel = 1; int warmup = 0; int repetitions = TRIES; int msize = 4; char buf[256]; char *usage = "-s\n OR [-S] [-m <message size>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] server\n NOTE: message size must be >= 4\n"; if (sizeof(int) != 4) { fprintf(stderr, "lat_udp: Wrong sequence size\n"); return(1); } while (( c = getopt(ac, av, "sS:m:P:W:N:")) != EOF) { switch(c) { case 's': /* Server */ if (fork() == 0) { server_main(); } exit(0); case 'S': /* shutdown serverhost */ { int seq, n; int sock = udp_connect(optarg, UDP_XACT, SOCKOPT_NONE); for (n = -1; n > -5; --n) { seq = htonl(n); (void) send(sock, &seq, sizeof(int), 0); } close(sock); exit (0); } case 'm': msize = atoi(optarg); if (msize < sizeof(int)) { lmbench_usage(ac, av, usage); msize = 4; } if (msize > MAX_MSIZE) { lmbench_usage(ac, av, usage); msize = MAX_MSIZE; } break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind + 1 != ac) { lmbench_usage(ac, av, usage); } state.server = av[optind]; state.msize = msize; benchmp(init, doit, cleanup, SHORT, parallel, warmup, repetitions, &state); sprintf(buf, "UDP latency using %s", state.server); micro(buf, get_n()); exit(0); }
int main(int ac, char **av) { int fd; struct stat sbuf; void *buf; int parallel = 1; int warmup = 0; int repetitions = TRIES; size_t nbytes; state_t state; int c; char *usage = "[-C] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] <size> open2close|mmap_only <filename>"; state.clone = 0; while (( c = getopt(ac, av, "P:W:N:C")) != EOF) { switch(c) { case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; case 'C': state.clone = 1; break; default: lmbench_usage(ac, av, usage); break; } } /* should have three arguments left (bytes type filename) */ if (optind + 3 != ac) { lmbench_usage(ac, av, usage); } nbytes = state.nbytes = bytes(av[optind]); strcpy(state.filename,av[optind+2]); CHK(stat(state.filename, &sbuf)); if ((S_ISREG(sbuf.st_mode) && nbytes > sbuf.st_size) || (nbytes < MINSZ)) { fprintf(stderr,"<size> out of range!\n"); exit(1); } if (!strcmp("open2close", av[optind+1])) { benchmp(initialize, time_with_open, cleanup, 0, parallel, warmup, repetitions, &state); } else if (!strcmp("mmap_only", av[optind+1])) { benchmp(init_open, time_no_open, cleanup, 0, parallel, warmup, repetitions, &state); } else { lmbench_usage(ac, av, usage); } bandwidth(nbytes, get_n() * parallel, 0); return (0); }
int main(int ac, char **av) { int c; int parallel = 1; int warmup = 0; int repetitions = -1; state_t state; CLIENT *cl; char buf[1024]; char *protocol = NULL; char *usage = "-s\n OR [-p <tcp|udp>] [-P parallel] [-W <warmup>] [-N <repetitions>] serverhost\n OR -S serverhost\n"; state.msize = 1; state.server = NULL; while (( c = getopt(ac, av, "sS:m:p:P:W:N:")) != EOF) { switch(c) { case 's': /* Server */ if (fork() == 0) { server_main(); } exit(0); case 'S': /* shutdown serverhost */ { cl = clnt_create(optarg, XACT_PROG, XACT_VERS, "udp"); if (!cl) { clnt_pcreateerror(state.server); exit(1); } clnt_call(cl, RPC_EXIT, (xdrproc_t)xdr_void, 0, (xdrproc_t)xdr_void, 0, TIMEOUT); exit(0); } case 'm': state.msize = atoi(optarg); break; case 'p': protocol = optarg; break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1) { lmbench_usage(ac, av, usage); } state.server = av[optind++]; if (protocol == NULL || !strcasecmp(protocol, proto[0])) { state.protocol = proto[0]; benchmp(initialize, benchmark, NULL, MEDIUM, parallel, warmup, repetitions, &state); sprintf(buf, "RPC/%s latency using %s", proto[0], state.server); micro(buf, get_n()); } if (protocol == NULL || !strcasecmp(protocol, proto[1])) { state.protocol = proto[1]; benchmp(initialize, benchmark, NULL, MEDIUM, parallel, warmup, repetitions, &state); sprintf(buf, "RPC/%s latency using %s", proto[1], state.server); micro(buf, get_n()); } exit(0); }
int main(int ac, char **av) { int c; int warmup = 0; int repetitions = TRIES; double par; struct _state state; char *usage = "[-W <warmup>] [-N <repetitions>]\n"; state.N = 1; state.M = 1000; state.K = -1023; while (( c = getopt(ac, av, "W:N:")) != EOF) { switch(c) { case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } par = max_parallelism(integer_bit_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "integer bit parallelism: %.2f\n", par); par = max_parallelism(integer_add_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "integer add parallelism: %.2f\n", par); par = max_parallelism(integer_mul_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "integer mul parallelism: %.2f\n", par); par = max_parallelism(integer_div_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "integer div parallelism: %.2f\n", par); par = max_parallelism(integer_mod_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "integer mod parallelism: %.2f\n", par); par = max_parallelism(int64_bit_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "int64 bit parallelism: %.2f\n", par); par = max_parallelism(int64_add_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "int64 add parallelism: %.2f\n", par); par = max_parallelism(int64_mul_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "int64 mul parallelism: %.2f\n", par); par = max_parallelism(int64_div_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "int64 div parallelism: %.2f\n", par); par = max_parallelism(int64_mod_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "int64 mod parallelism: %.2f\n", par); par = max_parallelism(float_add_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "float add parallelism: %.2f\n", par); par = max_parallelism(float_mul_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "float mul parallelism: %.2f\n", par); par = max_parallelism(float_div_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "float div parallelism: %.2f\n", par); par = max_parallelism(double_add_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "double add parallelism: %.2f\n", par); par = max_parallelism(double_mul_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "double mul parallelism: %.2f\n", par); par = max_parallelism(double_div_benchmarks, warmup, repetitions, &state); if (par > 0.) fprintf(stderr, "double div parallelism: %.2f\n", par); return(0); }
int main(int ac, char **av) { char *server; int i, prog; int c; int shutdown = 0; uint64 total = 0; uint64 usecs = 0; double avg; char *name = av[0]; char file[1024]; char *usage = "[-d] [-e] [-S] serverhost [port] < list\n"; while (( c = getopt(ac, av, "deS")) != EOF) { switch(c) { case 'd': debug++; break; case 'e': echo++; break; case 'S': /* shutdown serverhost */ shutdown = 1; break; default: lmbench_usage(ac, av, usage); break; } } if (optind >= ac || optind < ac - 2) { lmbench_usage(ac, av, usage); exit(0); } server = av[optind++]; if (optind < ac && atoi(av[optind]) != 0) { prog = -atoi(av[optind]); } else { prog = -80; } if (shutdown) { killhttp(server, prog); exit(0); } i = 0; buf = valloc(XFERSIZE); bzero(buf, XFERSIZE); while (fgets(file, sizeof(file), stdin)) { chop(file); start(0); total += http(server, file, prog); usecs += stop(0,0); i++; } avg = total; avg /= (i - 1); if (avg > 1000) { avg /= 1000; fprintf(stderr, "Avg xfer: %.1fKB, ", avg); } else { fprintf(stderr, "Avg xfer %d, ", (int)avg); } settime(usecs); latency((uint64)1, total); exit(0); }