tools/tools/syscall_timing/syscall_timing.c

   1 /*-
   2  * Copyright (c) 2003-2004, 2010 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Portions of this software were developed at the University of Cambridge
   6  * Computer Laboratory with support from a grant from Google, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/mman.h>
  34 #include <sys/socket.h>
  35 #include <sys/stat.h>
  36 #include <sys/time.h>
  37 #include <sys/wait.h>
  38
  39 #include <assert.h>
  40 #include <err.h>
  41 #include <fcntl.h>
  42 #include <inttypes.h>
  43 #include <limits.h>
  44 #include <signal.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49
  50 static struct timespec ts_start, ts_end;
  51 static int alarm_timeout;
  52 static volatile int alarm_fired;
  53
  54 #define timespecsub(vvp, uvp)                                           \
  55         do {                                                            \
  56                 (vvp)->tv_sec -= (uvp)->tv_sec;                         \
  57                 (vvp)->tv_nsec -= (uvp)->tv_nsec;                       \
  58                 if ((vvp)->tv_nsec < 0) {                               \
  59                         (vvp)->tv_sec--;                                \
  60                         (vvp)->tv_nsec += 1000000000;                   \
  61                 }                                                       \
  62         } while (0)
  63
  64 static void
  65 alarm_handler(int signum)
  66 {
  67
  68         alarm_fired = 1;
  69 }
  70
  71 static void
  72 benchmark_start(void)
  73 {
  74         int error;
  75
  76         alarm_fired = 0;
  77         if (alarm_timeout) {
  78                 signal(SIGALRM, alarm_handler);
  79                 alarm(alarm_timeout);
  80         }
  81         error = clock_gettime(CLOCK_REALTIME, &ts_start);
  82         assert(error == 0);
  83 }
  84
  85 static void
  86 benchmark_stop(void)
  87 {
  88         int error;
  89
  90         error = clock_gettime(CLOCK_REALTIME, &ts_end);
  91         assert(error == 0);
  92 }
  93
  94 uintmax_t
  95 test_getuid(uintmax_t num, uintmax_t int_arg, const char *path)
  96 {
  97         uintmax_t i;
  98
  99         /*
 100          * Thread-local data should require no locking if system
 101          * call is MPSAFE.
 102          */
 103         benchmark_start();
 104         for (i = 0; i < num; i++) {
 105                 if (alarm_fired)
 106                         break;
 107                 getuid();
 108         }
 109         benchmark_stop();
 110         return (i);
 111 }
 112
 113 uintmax_t
 114 test_getppid(uintmax_t num, uintmax_t int_arg, const char *path)
 115 {
 116         uintmax_t i;
 117
 118         /*
 119          * This is process-local, but can change, so will require a
 120          * lock.
 121          */
 122         benchmark_start();
 123         for (i = 0; i < num; i++) {
 124                 if (alarm_fired)
 125                         break;
 126                 getppid();
 127         }
 128         benchmark_stop();
 129         return (i);
 130 }
 131
 132 uintmax_t
 133 test_clock_gettime(uintmax_t num, uintmax_t int_arg, const char *path)
 134 {
 135         struct timespec ts;
 136         uintmax_t i;
 137
 138         benchmark_start();
 139         for (i = 0; i < num; i++) {
 140                 if (alarm_fired)
 141                         break;
 142                 (void)clock_gettime(CLOCK_REALTIME, &ts);
 143         }
 144         benchmark_stop();
 145         return (i);
 146 }
 147
 148 uintmax_t
 149 test_gettimeofday(uintmax_t num, uintmax_t int_arg, const char *path)
 150 {
 151         struct timeval tv;
 152         uintmax_t i;
 153
 154         benchmark_start();
 155         for (i = 0; i < num; i++) {
 156                 if (alarm_fired)
 157                         break;
 158                 (void)gettimeofday(&tv, NULL);
 159         }
 160         benchmark_stop();
 161         return (i);
 162 }
 163
 164 uintmax_t
 165 test_pipe(uintmax_t num, uintmax_t int_arg, const char *path)
 166 {
 167         int fd[2], i;
 168
 169         /*
 170          * pipe creation is expensive, as it will allocate a new file
 171          * descriptor, allocate a new pipe, hook it all up, and return.
 172          * Destroying is also expensive, as we now have to free up
 173          * the file descriptors and return the pipe.
 174          */
 175         if (pipe(fd) < 0)
 176                 err(-1, "test_pipe: pipe");
 177         close(fd[0]);
 178         close(fd[1]);
 179         benchmark_start();
 180         for (i = 0; i < num; i++) {
 181                 if (alarm_fired)
 182                         break;
 183                 if (pipe(fd) == -1)
 184                         err(-1, "test_pipe: pipe");
 185                 close(fd[0]);
 186                 close(fd[1]);
 187         }
 188         benchmark_stop();
 189         return (i);
 190 }
 191
 192 uintmax_t
 193 test_socket_stream(uintmax_t num, uintmax_t int_arg, const char *path)
 194 {
 195         uintmax_t i;
 196         int so;
 197
 198         so = socket(int_arg, SOCK_STREAM, 0);
 199         if (so < 0)
 200                 err(-1, "test_socket_stream: socket");
 201         close(so);
 202         benchmark_start();
 203         for (i = 0; i < num; i++) {
 204                 if (alarm_fired)
 205                         break;
 206                 so = socket(int_arg, SOCK_STREAM, 0);
 207                 if (so == -1)
 208                         err(-1, "test_socket_stream: socket");
 209                 close(so);
 210         }
 211         benchmark_stop();
 212         return (i);
 213 }
 214
 215 uintmax_t
 216 test_socket_dgram(uintmax_t num, uintmax_t int_arg, const char *path)
 217 {
 218         uintmax_t i;
 219         int so;
 220
 221         so = socket(int_arg, SOCK_DGRAM, 0);
 222         if (so < 0)
 223                 err(-1, "test_socket_dgram: socket");
 224         close(so);
 225         benchmark_start();
 226         for (i = 0; i < num; i++) {
 227                 if (alarm_fired)
 228                         break;
 229                 so = socket(int_arg, SOCK_DGRAM, 0);
 230                 if (so == -1)
 231                         err(-1, "test_socket_dgram: socket");
 232                 close(so);
 233         }
 234         benchmark_stop();
 235         return (i);
 236 }
 237
 238 uintmax_t
 239 test_socketpair_stream(uintmax_t num, uintmax_t int_arg, const char *path)
 240 {
 241         uintmax_t i;
 242         int so[2];
 243
 244         if (socketpair(PF_LOCAL, SOCK_STREAM, 0, so) == -1)
 245                 err(-1, "test_socketpair_stream: socketpair");
 246         close(so[0]);
 247         close(so[1]);
 248         benchmark_start();
 249         for (i = 0; i < num; i++) {
 250                 if (alarm_fired)
 251                         break;
 252                 if (socketpair(PF_LOCAL, SOCK_STREAM, 0, so) == -1)
 253                         err(-1, "test_socketpair_stream: socketpair");
 254                 close(so[0]);
 255                 close(so[1]);
 256         }
 257         benchmark_stop();
 258         return (i);
 259 }
 260
 261 uintmax_t
 262 test_socketpair_dgram(uintmax_t num, uintmax_t int_arg, const char *path)
 263 {
 264         uintmax_t i;
 265         int so[2];
 266
 267         if (socketpair(PF_LOCAL, SOCK_DGRAM, 0, so) == -1)
 268                 err(-1, "test_socketpair_dgram: socketpair");
 269         close(so[0]);
 270         close(so[1]);
 271         benchmark_start();
 272         for (i = 0; i < num; i++) {
 273                 if (alarm_fired)
 274                         break;
 275                 if (socketpair(PF_LOCAL, SOCK_DGRAM, 0, so) == -1)
 276                         err(-1, "test_socketpair_dgram: socketpair");
 277                 close(so[0]);
 278                 close(so[1]);
 279         }
 280         benchmark_stop();
 281         return (i);
 282 }
 283
 284 uintmax_t
 285 test_create_unlink(uintmax_t num, uintmax_t int_arg, const char *path)
 286 {
 287         uintmax_t i;
 288         int fd;
 289
 290         (void)unlink(path);
 291         fd = open(path, O_RDWR | O_CREAT, 0600);
 292         if (fd < 0)
 293                 err(-1, "test_create_unlink: create: %s", path);
 294         close(fd);
 295         if (unlink(path) < 0)
 296                 err(-1, "test_create_unlink: unlink: %s", path);
 297         benchmark_start();
 298         for (i = 0; i < num; i++) {
 299                 if (alarm_fired)
 300                         break;
 301                 fd = open(path, O_RDWR | O_CREAT, 0600);
 302                 if (fd < 0)
 303                         err(-1, "test_create_unlink: create: %s", path);
 304                 close(fd);
 305                 if (unlink(path) < 0)
 306                         err(-1, "test_create_unlink: unlink: %s", path);
 307         }
 308         benchmark_stop();
 309         return (i);
 310 }
 311
 312 uintmax_t
 313 test_open_close(uintmax_t num, uintmax_t int_arg, const char *path)
 314 {
 315         uintmax_t i;
 316         int fd;
 317
 318         fd = open(path, O_RDONLY);
 319         if (fd < 0)
 320                 err(-1, "test_open_close: %s", path);
 321         close(fd);
 322
 323         benchmark_start();
 324         for (i = 0; i < num; i++) {
 325                 if (alarm_fired)
 326                         break;
 327                 fd = open(path, O_RDONLY);
 328                 if (fd < 0)
 329                         err(-1, "test_open_close: %s", path);
 330                 close(fd);
 331         }
 332         benchmark_stop();
 333         return (i);
 334 }
 335
 336 uintmax_t
 337 test_read(uintmax_t num, uintmax_t int_arg, const char *path)
 338 {
 339         char buf[int_arg];
 340         uintmax_t i;
 341         int fd;
 342
 343         fd = open(path, O_RDONLY);
 344         if (fd < 0)
 345                 err(-1, "test_open_read: %s", path);
 346         (void)pread(fd, buf, int_arg, 0);
 347
 348         benchmark_start();
 349         for (i = 0; i < num; i++) {
 350                 if (alarm_fired)
 351                         break;
 352                 (void)pread(fd, buf, int_arg, 0);
 353         }
 354         benchmark_stop();
 355         close(fd);
 356         return (i);
 357 }
 358
 359 uintmax_t
 360 test_open_read_close(uintmax_t num, uintmax_t int_arg, const char *path)
 361 {
 362         char buf[int_arg];
 363         uintmax_t i;
 364         int fd;
 365
 366         fd = open(path, O_RDONLY);
 367         if (fd < 0)
 368                 err(-1, "test_open_read_close: %s", path);
 369         (void)read(fd, buf, int_arg);
 370         close(fd);
 371
 372         benchmark_start();
 373         for (i = 0; i < num; i++) {
 374                 if (alarm_fired)
 375                         break;
 376                 fd = open(path, O_RDONLY);
 377                 if (fd < 0)
 378                         err(-1, "test_open_read_close: %s", path);
 379                 (void)read(fd, buf, int_arg);
 380                 close(fd);
 381         }
 382         benchmark_stop();
 383         return (i);
 384 }
 385
 386 uintmax_t
 387 test_dup(uintmax_t num, uintmax_t int_arg, const char *path)
 388 {
 389         int fd, i, shmfd;
 390
 391         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 392         if (shmfd < 0)
 393                 err(-1, "test_dup: shm_open");
 394         fd = dup(shmfd);
 395         if (fd >= 0)
 396                 close(fd);
 397         benchmark_start();
 398         for (i = 0; i < num; i++) {
 399                 if (alarm_fired)
 400                         break;
 401                 fd = dup(shmfd);
 402                 if (fd >= 0)
 403                         close(fd);
 404         }
 405         benchmark_stop();
 406         close(shmfd);
 407         return (i);
 408 }
 409
 410 uintmax_t
 411 test_shmfd(uintmax_t num, uintmax_t int_arg, const char *path)
 412 {
 413         uintmax_t i;
 414         int shmfd;
 415
 416         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 417         if (shmfd < 0)
 418                 err(-1, "test_shmfd: shm_open");
 419         close(shmfd);
 420         benchmark_start();
 421         for (i = 0; i < num; i++) {
 422                 if (alarm_fired)
 423                         break;
 424                 shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 425                 if (shmfd < 0)
 426                         err(-1, "test_shmfd: shm_open");
 427                 close(shmfd);
 428         }
 429         benchmark_stop();
 430         return (i);
 431 }
 432
 433 uintmax_t
 434 test_fstat_shmfd(uintmax_t num, uintmax_t int_arg, const char *path)
 435 {
 436         struct stat sb;
 437         uintmax_t i;
 438         int shmfd;
 439
 440         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 441         if (shmfd < 0)
 442                 err(-1, "test_fstat_shmfd: shm_open");
 443         if (fstat(shmfd, &sb) < 0)
 444                 err(-1, "test_fstat_shmfd: fstat");
 445         benchmark_start();
 446         for (i = 0; i < num; i++) {
 447                 if (alarm_fired)
 448                         break;
 449                 (void)fstat(shmfd, &sb);
 450         }
 451         benchmark_stop();
 452         close(shmfd);
 453         return (i);
 454 }
 455
 456 uintmax_t
 457 test_fork(uintmax_t num, uintmax_t int_arg, const char *path)
 458 {
 459         pid_t pid;
 460         uintmax_t i;
 461
 462         pid = fork();
 463         if (pid < 0)
 464                 err(-1, "test_fork: fork");
 465         if (pid == 0)
 466                 _exit(0);
 467         if (waitpid(pid, NULL, 0) < 0)
 468                 err(-1, "test_fork: waitpid");
 469         benchmark_start();
 470         for (i = 0; i < num; i++) {
 471                 if (alarm_fired)
 472                         break;
 473                 pid = fork();
 474                 if (pid < 0)
 475                         err(-1, "test_fork: fork");
 476                 if (pid == 0)
 477                         _exit(0);
 478                 if (waitpid(pid, NULL, 0) < 0)
 479                         err(-1, "test_fork: waitpid");
 480         }
 481         benchmark_stop();
 482         return (i);
 483 }
 484
 485 uintmax_t
 486 test_vfork(uintmax_t num, uintmax_t int_arg, const char *path)
 487 {
 488         pid_t pid;
 489         uintmax_t i;
 490
 491         pid = vfork();
 492         if (pid < 0)
 493                 err(-1, "test_vfork: vfork");
 494         if (pid == 0)
 495                 _exit(0);
 496         if (waitpid(pid, NULL, 0) < 0)
 497                 err(-1, "test_vfork: waitpid");
 498         benchmark_start();
 499         for (i = 0; i < num; i++) {
 500                 if (alarm_fired)
 501                         break;
 502                 pid = vfork();
 503                 if (pid < 0)
 504                         err(-1, "test_vfork: vfork");
 505                 if (pid == 0)
 506                         _exit(0);
 507                 if (waitpid(pid, NULL, 0) < 0)
 508                         err(-1, "test_vfork: waitpid");
 509         }
 510         benchmark_stop();
 511         return (i);
 512 }
 513
 514 #define USR_BIN_TRUE    "/usr/bin/true"
 515 static char *execve_args[] = { USR_BIN_TRUE, NULL};
 516 extern char **environ;
 517
 518 uintmax_t
 519 test_fork_exec(uintmax_t num, uintmax_t int_arg, const char *path)
 520 {
 521         pid_t pid;
 522         uintmax_t i;
 523
 524         pid = fork();
 525         if (pid < 0)
 526                 err(-1, "test_fork_exec: fork");
 527         if (pid == 0) {
 528                 (void)execve(USR_BIN_TRUE, execve_args, environ);
 529                 err(-1, "execve");
 530         }
 531         if (waitpid(pid, NULL, 0) < 0)
 532                 err(-1, "test_fork: waitpid");
 533         benchmark_start();
 534         for (i = 0; i < num; i++) {
 535                 if (alarm_fired)
 536                         break;
 537                 pid = fork();
 538                 if (pid < 0)
 539                         err(-1, "test_fork_exec: fork");
 540                 if (pid == 0) {
 541                         (void)execve(USR_BIN_TRUE, execve_args, environ);
 542                         err(-1, "test_fork_exec: execve");
 543                 }
 544                 if (waitpid(pid, NULL, 0) < 0)
 545                         err(-1, "test_fork_exec: waitpid");
 546         }
 547         benchmark_stop();
 548         return (i);
 549 }
 550
 551 uintmax_t
 552 test_vfork_exec(uintmax_t num, uintmax_t int_arg, const char *path)
 553 {
 554         pid_t pid;
 555         uintmax_t i;
 556
 557         pid = vfork();
 558         if (pid < 0)
 559                 err(-1, "test_vfork_exec: vfork");
 560         if (pid == 0) {
 561                 (void)execve(USR_BIN_TRUE, execve_args, environ);
 562                 err(-1, "test_vfork_exec: execve");
 563         }
 564         if (waitpid(pid, NULL, 0) < 0)
 565                 err(-1, "test_vfork_exec: waitpid");
 566         benchmark_start();
 567         for (i = 0; i < num; i++) {
 568                 if (alarm_fired)
 569                         break;
 570                 pid = vfork();
 571                 if (pid < 0)
 572                         err(-1, "test_vfork_exec: vfork");
 573                 if (pid == 0) {
 574                         (void)execve(USR_BIN_TRUE, execve_args, environ);
 575                         err(-1, "execve");
 576                 }
 577                 if (waitpid(pid, NULL, 0) < 0)
 578                         err(-1, "test_vfork_exec: waitpid");
 579         }
 580         benchmark_stop();
 581         return (i);
 582 }
 583
 584 uintmax_t
 585 test_chroot(uintmax_t num, uintmax_t int_arg, const char *path)
 586 {
 587         uintmax_t i;
 588
 589         if (chroot("/") < 0)
 590                 err(-1, "test_chroot: chroot");
 591         benchmark_start();
 592         for (i = 0; i < num; i++) {
 593                 if (alarm_fired)
 594                         break;
 595                 if (chroot("/") < 0)
 596                         err(-1, "test_chroot: chroot");
 597         }
 598         benchmark_stop();
 599         return (i);
 600 }
 601
 602 uintmax_t
 603 test_setuid(uintmax_t num, uintmax_t int_arg, const char *path)
 604 {
 605         uid_t uid;
 606         uintmax_t i;
 607
 608         uid = getuid();
 609         if (setuid(uid) < 0)
 610                 err(-1, "test_setuid: setuid");
 611         benchmark_start();
 612         for (i = 0; i < num; i++) {
 613                 if (alarm_fired)
 614                         break;
 615                 if (setuid(uid) < 0)
 616                         err(-1, "test_setuid: setuid");
 617         }
 618         benchmark_stop();
 619         return (i);
 620 }
 621
 622 struct test {
 623         const char      *t_name;
 624         uintmax_t       (*t_func)(uintmax_t, uintmax_t, const char *);
 625         int              t_flags;
 626         uintmax_t        t_int;
 627 };
 628
 629 #define FLAG_PATH       0x00000001
 630
 631 static const struct test tests[] = {
 632         { "getuid", test_getuid },
 633         { "getppid", test_getppid },
 634         { "clock_gettime", test_clock_gettime },
 635         { "gettimeofday", test_gettimeofday },
 636         { "pipe", test_pipe },
 637         { "socket_local_stream", test_socket_stream, .t_int = PF_LOCAL },
 638         { "socket_local_dgram", test_socket_dgram, .t_int = PF_LOCAL },
 639         { "socketpair_stream", test_socketpair_stream },
 640         { "socketpair_dgram", test_socketpair_dgram },
 641         { "socket_tcp", test_socket_stream, .t_int = PF_INET },
 642         { "socket_udp", test_socket_dgram, .t_int = PF_INET },
 643         { "create_unlink", test_create_unlink, .t_flags = FLAG_PATH },
 644         { "open_close", test_open_close, .t_flags = FLAG_PATH },
 645         { "open_read_close_1", test_open_read_close, .t_flags = FLAG_PATH,
 646             .t_int = 1 },
 647         { "open_read_close_10", test_open_read_close, .t_flags = FLAG_PATH,
 648             .t_int = 10 },
 649         { "open_read_close_100", test_open_read_close, .t_flags = FLAG_PATH,
 650             .t_int = 100 },
 651         { "open_read_close_1000", test_open_read_close, .t_flags = FLAG_PATH,
 652             .t_int = 1000 },
 653         { "open_read_close_10000", test_open_read_close,
 654             .t_flags = FLAG_PATH, .t_int = 10000 },
 655         { "open_read_close_100000", test_open_read_close,
 656             .t_flags = FLAG_PATH, .t_int = 100000 },
 657         { "open_read_close_1000000", test_open_read_close,
 658             .t_flags = FLAG_PATH, .t_int = 1000000 },
 659         { "read_1", test_read, .t_flags = FLAG_PATH, .t_int = 1 },
 660         { "read_10", test_read, .t_flags = FLAG_PATH, .t_int = 10 },
 661         { "read_100", test_read, .t_flags = FLAG_PATH, .t_int = 100 },
 662         { "read_1000", test_read, .t_flags = FLAG_PATH, .t_int = 1000 },
 663         { "read_10000", test_read, .t_flags = FLAG_PATH, .t_int = 10000 },
 664         { "read_100000", test_read, .t_flags = FLAG_PATH, .t_int = 100000 },
 665         { "read_1000000", test_read, .t_flags = FLAG_PATH, .t_int = 1000000 },
 666         { "dup", test_dup },
 667         { "shmfd", test_shmfd },
 668         { "fstat_shmfd", test_fstat_shmfd },
 669         { "fork", test_fork },
 670         { "vfork", test_vfork },
 671         { "fork_exec", test_fork_exec },
 672         { "vfork_exec", test_vfork_exec },
 673         { "chroot", test_chroot },
 674         { "setuid", test_setuid },
 675 };
 676 static const int tests_count = sizeof(tests) / sizeof(tests[0]);
 677
 678 static void
 679 usage(void)
 680 {
 681         int i;
 682
 683         fprintf(stderr, "syscall_timing [-i iterations] [-l loops] "
 684             "[-p path] [-s seconds] test\n");
 685         for (i = 0; i < tests_count; i++)
 686                 fprintf(stderr, "  %s\n", tests[i].t_name);
 687         exit(-1);
 688 }
 689
 690 int
 691 main(int argc, char *argv[])
 692 {
 693         struct timespec ts_res;
 694         const struct test *the_test;
 695         const char *path;
 696         long long ll;
 697         char *endp;
 698         int ch, error, i, j, k;
 699         uintmax_t iterations, loops;
 700
 701         alarm_timeout = 1;
 702         iterations = 0;
 703         loops = 10;
 704         path = NULL;
 705         while ((ch = getopt(argc, argv, "i:l:p:s:")) != -1) {
 706                 switch (ch) {
 707                 case 'i':
 708                         ll = strtol(optarg, &endp, 10);
 709                         if (*endp != 0 || ll < 1 || ll > 100000)
 710                                 usage();
 711                         iterations = ll;
 712                         break;
 713
 714                 case 'l':
 715                         ll = strtol(optarg, &endp, 10);
 716                         if (*endp != 0 || ll < 1 || ll > 100000)
 717                                 usage();
 718                         loops = ll;
 719                         break;
 720
 721                 case 'p':
 722                         path = optarg;
 723                         break;
 724
 725                 case 's':
 726                         ll = strtol(optarg, &endp, 10);
 727                         if (*endp != 0 || ll < 1 || ll > 60*60)
 728                                 usage();
 729                         alarm_timeout = ll;
 730                         break;
 731
 732                 case '?':
 733                 default:
 734                         usage();
 735                 }
 736         }
 737         argc -= optind;
 738         argv += optind;
 739
 740         if (iterations < 1 && alarm_timeout < 1)
 741                 usage();
 742         if (iterations < 1)
 743                 iterations = UINT64_MAX;
 744         if (loops < 1)
 745                 loops = 1;
 746
 747         if (argc < 1)
 748                 usage();
 749
 750         /*
 751          * Validate test list and that, if a path is required, it is
 752          * defined.
 753          */
 754         for (j = 0; j < argc; j++) {
 755                 the_test = NULL;
 756                 for (i = 0; i < tests_count; i++) {
 757                         if (strcmp(argv[j], tests[i].t_name) == 0)
 758                                 the_test = &tests[i];
 759                 }
 760                 if (the_test == NULL)
 761                         usage();
 762                 if ((the_test->t_flags & FLAG_PATH) && (path == NULL)) {
 763                         errx(-1, "%s requires -p", the_test->t_name);
 764                 }
 765         }
 766
 767         error = clock_getres(CLOCK_REALTIME, &ts_res);
 768         assert(error == 0);
 769         printf("Clock resolution: %ju.%09ju\n", (uintmax_t)ts_res.tv_sec,
 770             (uintmax_t)ts_res.tv_nsec);
 771         printf("test\tloop\ttime\titerations\tperiteration\n");
 772
 773         for (j = 0; j < argc; j++) {
 774                 uintmax_t calls, nsecsperit;
 775
 776                 the_test = NULL;
 777                 for (i = 0; i < tests_count; i++) {
 778                         if (strcmp(argv[j], tests[i].t_name) == 0)
 779                                 the_test = &tests[i];
 780                 }
 781
 782                 /*
 783                  * Run one warmup, then do the real thing (loops) times.
 784                  */
 785                 the_test->t_func(iterations, the_test->t_int, path);
 786                 calls = 0;
 787                 for (k = 0; k < loops; k++) {
 788                         calls = the_test->t_func(iterations, the_test->t_int,
 789                             path);
 790                         timespecsub(&ts_end, &ts_start);
 791                         printf("%s\t%d\t", the_test->t_name, k);
 792                         printf("%ju.%09ju\t%ju\t", (uintmax_t)ts_end.tv_sec,
 793                             (uintmax_t)ts_end.tv_nsec, calls);
 794
 795                 /*
 796                  * Note.  This assumes that each iteration takes less than
 797                  * a second, and that our total nanoseconds doesn't exceed
 798                  * the room in our arithmetic unit.  Fine for system calls,
 799                  * but not for long things.
 800                  */
 801                         nsecsperit = ts_end.tv_sec * 1000000000;
 802                         nsecsperit += ts_end.tv_nsec;
 803                         nsecsperit /= calls;
 804                         printf("0.%09ju\n", (uintmax_t)nsecsperit);
 805                 }
 806         }
 807         return (0);
 808 }