tests/Gperf-simple.c

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2003-2004 Hewlett-Packard Co
   3         Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   4
   5 Permission is hereby granted, free of charge, to any person obtaining
   6 a copy of this software and associated documentation files (the
   7 "Software"), to deal in the Software without restriction, including
   8 without limitation the rights to use, copy, modify, merge, publish,
   9 distribute, sublicense, and/or sell copies of the Software, and to
  10 permit persons to whom the Software is furnished to do so, subject to
  11 the following conditions:
  12
  13 The above copyright notice and this permission notice shall be
  14 included in all copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  23
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28
  29 #include <libunwind.h>
  30 #include "compiler.h"
  31
  32 #include <sys/resource.h>
  33 #include <sys/time.h>
  34
  35 #define panic(args...)                                                    \
  36         do { fprintf (stderr, args); exit (-1); } while (0)
  37
  38 long dummy;
  39
  40 static long iterations = 10000;
  41 static int maxlevel = 100;
  42
  43 #define KB      1024
  44 #define MB      (1024*1024)
  45
  46 static char big[64*MB]; /* should be >> max. cache size */
  47
  48 static inline double
  49 gettime (void)
  50 {
  51   struct timeval tv;
  52
  53   gettimeofday (&tv, NULL);
  54   return tv.tv_sec + 1e-6*tv.tv_usec;
  55 }
  56
  57 static int NOINLINE
  58 measure_unwind (int maxlevel, double *step)
  59 {
  60   double stop, start;
  61   unw_cursor_t cursor;
  62   unw_context_t uc;
  63   int ret, level = 0;
  64
  65   unw_getcontext (&uc);
  66   if (unw_init_local (&cursor, &uc) < 0)
  67     panic ("unw_init_local() failed\n");
  68
  69   start = gettime ();
  70
  71   do
  72     {
  73       ret = unw_step (&cursor);
  74       if (ret < 0)
  75         panic ("unw_step() failed\n");
  76       ++level;
  77     }
  78   while (ret > 0);
  79
  80   stop = gettime ();
  81
  82   if (level <= maxlevel)
  83     panic ("Unwound only %d levels, expected at least %d levels\n",
  84            level, maxlevel);
  85
  86   *step = (stop - start) / (double) level;
  87   return 0;
  88 }
  89
  90 static int f1 (int, int, double *);
  91
  92 static int NOINLINE
  93 g1 (int level, int maxlevel, double *step)
  94 {
  95   if (level == maxlevel)
  96     return measure_unwind (maxlevel, step);
  97   else
  98     /* defeat last-call/sibcall optimization */
  99     return f1 (level + 1, maxlevel, step) + level;
 100 }
 101
 102 static int NOINLINE
 103 f1 (int level, int maxlevel, double *step)
 104 {
 105   if (level == maxlevel)
 106     return measure_unwind (maxlevel, step);
 107   else
 108     /* defeat last-call/sibcall optimization */
 109     return g1 (level + 1, maxlevel, step) + level;
 110 }
 111
 112 static void
 113 doit (const char *label)
 114 {
 115   double step, min_step, first_step, sum_step;
 116   int i;
 117
 118   sum_step = first_step = 0.0;
 119   min_step = 1e99;
 120   for (i = 0; i < iterations; ++i)
 121     {
 122       f1 (0, maxlevel, &step);
 123
 124       sum_step += step;
 125
 126       if (step < min_step)
 127         min_step = step;
 128
 129       if (i == 0)
 130         first_step = step;
 131     }
 132   printf ("%s: unw_step : 1st=%9.3f min=%9.3f avg=%9.3f nsec\n", label,
 133           1e9*first_step, 1e9*min_step, 1e9*sum_step/iterations);
 134 }
 135
 136 static long
 137 sum (void *buf, size_t size)
 138 {
 139   long s = 0;
 140   char *cp = buf;
 141   size_t i;
 142
 143   for (i = 0; i < size; i += 8)
 144     s += cp[i];
 145   return s;
 146 }
 147
 148 static void
 149 measure_init (void)
 150 {
 151 # define N      100
 152 # define M      10      /* must be at least 2 to get steady-state */
 153   double stop, start, get_cold, get_warm, init_cold, init_warm, delta;
 154   struct
 155     {
 156       unw_cursor_t c;
 157       char padding[1024];       /* should be > 2 * max. cacheline size */
 158     }
 159   cursor[N];
 160   struct
 161     {
 162       unw_context_t uc;
 163       char padding[1024];       /* should be > 2 * max. cacheline size */
 164     }
 165   uc[N];
 166   int i, j;
 167
 168   /* Run each test M times and take the minimum to filter out noise
 169      such dynamic linker resolving overhead, context-switches,
 170      page-in, cache, and TLB effects.  */
 171
 172   get_cold = 1e99;
 173   for (j = 0; j < M; ++j)
 174     {
 175       dummy += sum (big, sizeof (big));                 /* flush the cache */
 176       for (i = 0; i < N; ++i)
 177         uc[i].padding[511] = i;         /* warm up the TLB */
 178       start = gettime ();
 179       for (i = 0; i < N; ++i)
 180         unw_getcontext (&uc[i].uc);
 181       stop = gettime ();
 182       delta = (stop - start) / N;
 183       if (delta < get_cold)
 184         get_cold = delta;
 185     }
 186
 187   init_cold = 1e99;
 188   for (j = 0; j < M; ++j)
 189     {
 190       dummy += sum (big, sizeof (big)); /* flush cache */
 191       for (i = 0; i < N; ++i)
 192         uc[i].padding[511] = i;         /* warm up the TLB */
 193       start = gettime ();
 194       for (i = 0; i < N; ++i)
 195         unw_init_local (&cursor[i].c, &uc[i].uc);
 196       stop = gettime ();
 197       delta = (stop - start) / N;
 198       if (delta < init_cold)
 199         init_cold = delta;
 200     }
 201
 202   get_warm = 1e99;
 203   for (j = 0; j < M; ++j)
 204     {
 205       start = gettime ();
 206       for (i = 0; i < N; ++i)
 207         unw_getcontext (&uc[0].uc);
 208       stop = gettime ();
 209       delta = (stop - start) / N;
 210       if (delta < get_warm)
 211         get_warm = delta;
 212     }
 213
 214   init_warm = 1e99;
 215   for (j = 0; j < M; ++j)
 216     {
 217       start = gettime ();
 218       for (i = 0; i < N; ++i)
 219         unw_init_local (&cursor[0].c, &uc[0].uc);
 220       stop = gettime ();
 221       delta = (stop - start) / N;
 222       if (delta < init_warm)
 223         init_warm = delta;
 224     }
 225
 226   printf ("unw_getcontext : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
 227           1e9 * get_cold, 1e9 * get_warm);
 228   printf ("unw_init_local : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
 229           1e9 * init_cold, 1e9 * init_warm);
 230 }
 231
 232 int
 233 main (int argc, char **argv)
 234 {
 235   struct rlimit rlim;
 236
 237   rlim.rlim_cur = RLIM_INFINITY;
 238   rlim.rlim_max = RLIM_INFINITY;
 239   setrlimit (RLIMIT_STACK, &rlim);
 240
 241   memset (big, 0xaa, sizeof (big));
 242
 243   if (argc > 1)
 244     {
 245       maxlevel = atol (argv[1]);
 246       if (argc > 2)
 247         iterations = atol (argv[2]);
 248     }
 249
 250   measure_init ();
 251
 252   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_NONE);
 253   doit ("no cache        ");
 254
 255   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_GLOBAL);
 256   doit ("global cache    ");
 257
 258   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_PER_THREAD);
 259   doit ("per-thread cache");
 260
 261   return 0;
 262 }