test/bench.cpp

   1 /*
   2  * Copyright 2003 Niels Provos <provos@citi.umich.edu>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  *
  28  * Mon 03/10/2003 - Modified by Davide Libenzi <davidel@xmailserver.org>
  29  *
  30  *     Added chain event propagation to improve the sensitivity of
  31  *     the measure respect to the event loop efficency.
  32  *
  33  * Wed 2006-12-27 - Modified by Leandro Lucarella <llucax+eventxx@gmail.com>
  34  *
  35  *     Adapted to test the C++ inteface.
  36  *
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include "config.h"
  41 #endif
  42
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45 #include <sys/time.h>
  46 #include <sys/socket.h>
  47 #include <sys/signal.h>
  48 #include <sys/resource.h>
  49 #include <fcntl.h>
  50 #include <unistd.h>
  51 #include <cstdlib>
  52 #include <cstdio>
  53 #include <cstring>
  54 #include <cassert>
  55 #include <cerrno>
  56 #include <vector>
  57
  58 #include <eventxx>
  59
  60
  61 static int count, writes, fired;
  62 static int *pipes;
  63 static int num_pipes, num_active, num_writes;
  64 static std::vector< eventxx::cevent* > events;
  65 static eventxx::dispatcher d;
  66
  67
  68 void
  69 read_cb(int fd, short which, void *arg)
  70 {
  71         int idx = (int) arg, widx = idx + 1;
  72         u_char ch;
  73
  74         count += read(fd, &ch, sizeof(ch));
  75         if (writes) {
  76                 if (widx >= num_pipes)
  77                         widx -= num_pipes;
  78                 write(pipes[2 * widx + 1], "e", 1);
  79                 writes--;
  80                 fired++;
  81         }
  82 }
  83
  84 eventxx::time *
  85 run_once(void)
  86 {
  87         int *cp, i, space;
  88         static eventxx::time ts, te;
  89
  90         for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
  91                 events.push_back(new eventxx::cevent(cp[0],
  92                         eventxx::READ | eventxx::PERSIST, read_cb, (void *) i));
  93                 d.add(*events[i]);
  94         }
  95
  96         d.dispatch(EVLOOP_ONCE | EVLOOP_NONBLOCK);
  97
  98         fired = 0;
  99         space = num_pipes / num_active;
 100         space = space * 2;
 101         for (i = 0; i < num_active; i++, fired++)
 102                 write(pipes[i * space + 1], "e", 1);
 103
 104         count = 0;
 105         writes = num_writes;
 106         {
 107                 int xcount = 0;
 108                 gettimeofday(&ts, NULL);
 109                 do {
 110                         d.dispatch(EVLOOP_ONCE | EVLOOP_NONBLOCK);
 111                         xcount++;
 112                 } while (count != fired);
 113                 gettimeofday(&te, NULL);
 114
 115                 if (xcount != count) fprintf(stderr, "Xcount: %d, Rcount: %d\n", xcount, count);
 116         }
 117
 118         timersub(&te, &ts, &te);
 119
 120         for (i = 0; i < num_pipes; i++) {
 121                 d.del(*events[i]);
 122                 delete events[i];
 123         }
 124         events.clear();
 125
 126         return (&te);
 127 }
 128
 129 int
 130 main (int argc, char **argv)
 131 {
 132         struct rlimit rl;
 133         int i, c;
 134         eventxx::time* tv;
 135         int *cp;
 136         extern char *optarg;
 137
 138         num_pipes = 100;
 139         num_active = 1;
 140         num_writes = num_pipes;
 141         while ((c = getopt(argc, argv, "n:a:w:")) != -1) {
 142                 switch (c) {
 143                 case 'n':
 144                         num_pipes = atoi(optarg);
 145                         break;
 146                 case 'a':
 147                         num_active = atoi(optarg);
 148                         break;
 149                 case 'w':
 150                         num_writes = atoi(optarg);
 151                         break;
 152                 default:
 153                         fprintf(stderr, "Illegal argument \"%c\"\n", c);
 154                         exit(1);
 155                 }
 156         }
 157
 158         rl.rlim_cur = rl.rlim_max = num_pipes * 2 + 50;
 159         if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
 160                 perror("setrlimit");
 161                 exit(1);
 162         }
 163
 164         pipes = new int[num_pipes * 2];
 165
 166         for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
 167 #ifdef USE_PIPES
 168                 if (pipe(cp) == -1) {
 169 #else
 170                 if (socketpair(AF_UNIX, SOCK_STREAM, 0, cp) == -1) {
 171 #endif
 172                         perror("pipe");
 173                         exit(1);
 174                 }
 175         }
 176
 177         for (i = 0; i < 25; i++) {
 178                 tv = run_once();
 179                 assert(tv);
 180                 fprintf(stdout, "%ld\n",
 181                         tv->sec() * 1000000L + tv->usec());
 182         }
 183
 184         delete[] pipes;
 185
 186         exit(0);
 187 }