Home | History | Annotate | Download | only in tests 
      1 /* libunwind - a platform-independent unwind library
      2    Copyright (C) 2003-2004 Hewlett-Packard Co
      3 	Contributed by David Mosberger-Tang <davidm (at) 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   int level = 0;
     62   void *buffer[128];
     63 
     64   start = gettime ();
     65   level = unw_backtrace(buffer, 128);
     66   stop = gettime ();
     67 
     68   if (level <= maxlevel)
     69     panic ("Unwound only %d levels, expected at least %d levels\n",
     70 	   level, maxlevel);
     71 
     72   *step = (stop - start) / (double) level;
     73   return 0;
     74 }
     75 
     76 static int f1 (int, int, double *);
     77 
     78 static int NOINLINE
     79 g1 (int level, int maxlevel, double *step)
     80 {
     81   if (level == maxlevel)
     82     return measure_unwind (maxlevel, step);
     83   else
     84     /* defeat last-call/sibcall optimization */
     85     return f1 (level + 1, maxlevel, step) + level;
     86 }
     87 
     88 static int NOINLINE
     89 f1 (int level, int maxlevel, double *step)
     90 {
     91   if (level == maxlevel)
     92     return measure_unwind (maxlevel, step);
     93   else
     94     /* defeat last-call/sibcall optimization */
     95     return g1 (level + 1, maxlevel, step) + level;
     96 }
     97 
     98 static void
     99 doit (const char *label)
    100 {
    101   double step, min_step, first_step, sum_step;
    102   int i;
    103 
    104   sum_step = first_step = 0.0;
    105   min_step = 1e99;
    106   for (i = 0; i < iterations; ++i)
    107     {
    108       f1 (0, maxlevel, &step);
    109 
    110       sum_step += step;
    111 
    112       if (step < min_step)
    113 	min_step = step;
    114 
    115       if (i == 0)
    116 	first_step = step;
    117     }
    118   printf ("%s: unw_step : 1st=%9.3f min=%9.3f avg=%9.3f nsec\n", label,
    119 	  1e9*first_step, 1e9*min_step, 1e9*sum_step/iterations);
    120 }
    121 
    122 static long
    123 sum (void *buf, size_t size)
    124 {
    125   long s = 0;
    126   char *cp = buf;
    127   size_t i;
    128 
    129   for (i = 0; i < size; i += 8)
    130     s += cp[i];
    131   return s;
    132 }
    133 
    134 static void
    135 measure_init (void)
    136 {
    137 # define N	100
    138 # define M	10	/* must be at least 2 to get steady-state */
    139   double stop, start, get_cold, get_warm, init_cold, init_warm, delta;
    140   struct
    141     {
    142       unw_cursor_t c;
    143       char padding[1024];	/* should be > 2 * max. cacheline size */
    144     }
    145   cursor[N];
    146   struct
    147     {
    148       unw_context_t uc;
    149       char padding[1024];	/* should be > 2 * max. cacheline size */
    150     }
    151   uc[N];
    152   int i, j;
    153 
    154   /* Run each test M times and take the minimum to filter out noise
    155      such dynamic linker resolving overhead, context-switches,
    156      page-in, cache, and TLB effects.  */
    157 
    158   get_cold = 1e99;
    159   for (j = 0; j < M; ++j)
    160     {
    161       dummy += sum (big, sizeof (big));			/* flush the cache */
    162       for (i = 0; i < N; ++i)
    163 	uc[i].padding[511] = i;		/* warm up the TLB */
    164       start = gettime ();
    165       for (i = 0; i < N; ++i)
    166 	unw_getcontext (&uc[i].uc);
    167       stop = gettime ();
    168       delta = (stop - start) / N;
    169       if (delta < get_cold)
    170 	get_cold = delta;
    171     }
    172 
    173   init_cold = 1e99;
    174   for (j = 0; j < M; ++j)
    175     {
    176       dummy += sum (big, sizeof (big));	/* flush cache */
    177       for (i = 0; i < N; ++i)
    178 	uc[i].padding[511] = i;		/* warm up the TLB */
    179       start = gettime ();
    180       for (i = 0; i < N; ++i)
    181 	unw_init_local (&cursor[i].c, &uc[i].uc);
    182       stop = gettime ();
    183       delta = (stop - start) / N;
    184       if (delta < init_cold)
    185 	init_cold = delta;
    186     }
    187 
    188   get_warm = 1e99;
    189   for (j = 0; j < M; ++j)
    190     {
    191       start = gettime ();
    192       for (i = 0; i < N; ++i)
    193 	unw_getcontext (&uc[0].uc);
    194       stop = gettime ();
    195       delta = (stop - start) / N;
    196       if (delta < get_warm)
    197 	get_warm = delta;
    198     }
    199 
    200   init_warm = 1e99;
    201   for (j = 0; j < M; ++j)
    202     {
    203       start = gettime ();
    204       for (i = 0; i < N; ++i)
    205 	unw_init_local (&cursor[0].c, &uc[0].uc);
    206       stop = gettime ();
    207       delta = (stop - start) / N;
    208       if (delta < init_warm)
    209 	init_warm = delta;
    210     }
    211 
    212   printf ("unw_getcontext : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
    213 	  1e9 * get_cold, 1e9 * get_warm);
    214   printf ("unw_init_local : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
    215 	  1e9 * init_cold, 1e9 * init_warm);
    216 }
    217 
    218 int
    219 main (int argc, char **argv)
    220 {
    221   struct rlimit rlim;
    222 
    223   rlim.rlim_cur = RLIM_INFINITY;
    224   rlim.rlim_max = RLIM_INFINITY;
    225   setrlimit (RLIMIT_STACK, &rlim);
    226 
    227   memset (big, 0xaa, sizeof (big));
    228 
    229   if (argc > 1)
    230     {
    231       maxlevel = atol (argv[1]);
    232       if (argc > 2)
    233 	iterations = atol (argv[2]);
    234     }
    235 
    236   measure_init ();
    237 
    238   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_NONE);
    239   doit ("no cache        ");
    240 
    241   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_GLOBAL);
    242   doit ("global cache    ");
    243 
    244   unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_PER_THREAD);
    245   doit ("per-thread cache");
    246 
    247   return 0;
    248 }
    249