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 unsigned 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         size_t idx = (size_t) 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         size_t i;
  88         int *cp, space;
  89         static eventxx::time ts, te;
  90
  91         for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
  92                 events.push_back(new eventxx::cevent(cp[0],
  93                         eventxx::READ | eventxx::PERSIST, read_cb, (void *) i));
  94                 d.add(*events[i]);
  95         }
  96
  97         d.dispatch(eventxx::ONCE | eventxx::NONBLOCK);
  98
  99         fired = 0;
 100         space = num_pipes / num_active;
 101         space = space * 2;
 102         for (i = 0; i < num_active; i++, fired++)
 103                 write(pipes[i * space + 1], "e", 1);
 104
 105         count = 0;
 106         writes = num_writes;
 107         {
 108                 int xcount = 0;
 109                 gettimeofday(&ts, NULL);
 110                 do {
 111                         d.dispatch(EVLOOP_ONCE | EVLOOP_NONBLOCK);
 112                         xcount++;
 113                 } while (count != fired);
 114                 gettimeofday(&te, NULL);
 115
 116                 if (xcount != count) fprintf(stderr, "Xcount: %d, Rcount: %d\n", xcount, count);
 117         }
 118
 119         timersub(&te, &ts, &te);
 120
 121         for (i = 0; i < num_pipes; i++) {
 122                 d.del(*events[i]);
 123                 delete events[i];
 124         }
 125         events.clear();
 126
 127         return (&te);
 128 }
 129
 130 int
 131 main (int argc, char **argv)
 132 {
 133         struct rlimit rl;
 134         size_t i;
 135         eventxx::time* tv;
 136         int c, *cp;
 137         extern char *optarg;
 138
 139         num_pipes = 100;
 140         num_active = 1;
 141         num_writes = num_pipes;
 142         while ((c = getopt(argc, argv, "n:a:w:")) != -1) {
 143                 switch (c) {
 144                 case 'n':
 145                         num_pipes = atoi(optarg);
 146                         break;
 147                 case 'a':
 148                         num_active = atoi(optarg);
 149                         break;
 150                 case 'w':
 151                         num_writes = atoi(optarg);
 152                         break;
 153                 default:
 154                         fprintf(stderr, "Illegal argument \"%c\"\n", c);
 155                         exit(1);
 156                 }
 157         }
 158
 159         rl.rlim_cur = rl.rlim_max = num_pipes * 2 + 50;
 160         if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
 161                 perror("setrlimit");
 162                 exit(1);
 163         }
 164
 165         pipes = new int[num_pipes * 2];
 166
 167         for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
 168 #ifdef USE_PIPES
 169                 if (pipe(cp) == -1) {
 170 #else
 171                 if (socketpair(AF_UNIX, SOCK_STREAM, 0, cp) == -1) {
 172 #endif
 173                         perror("pipe");
 174                         exit(1);
 175                 }
 176         }
 177
 178         for (i = 0; i < 25; i++) {
 179                 tv = run_once();
 180                 assert(tv);
 181                 fprintf(stdout, "%ld\n",
 182                         tv->sec() * 1000000L + tv->usec());
 183         }
 184
 185         delete[] pipes;
 186
 187         exit(0);
 188 }