Add some performance tests for fast backtracing.

tests/Gperf-trace.c

@@ -0,0 +1,247 @@
+/* libunwind - a platform-independent unwind library
+   Copyright (C) 2003-2004 Hewlett-Packard Co
+	Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
+
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <libunwind.h>
+
+#include <sys/resource.h>
+#include <sys/time.h>
+
+#define panic(args...)							  \
+	do { fprintf (stderr, args); exit (-1); } while (0)
+
+long dummy;
+
+static long iterations = 10000;
+static int maxlevel = 100;
+
+#define KB	1024
+#define MB	(1024*1024)
+
+static char big[64*MB];	/* should be >> max. cache size */
+
+static inline double
+gettime (void)
+{
+  struct timeval tv;
+
+  gettimeofday (&tv, NULL);
+  return tv.tv_sec + 1e-6*tv.tv_usec;
+}
+
+static int __attribute__((noinline))
+measure_unwind (int maxlevel, double *step)
+{
+  double stop, start;
+  int level = 0;
+  void *buffer[128];
+
+  start = gettime ();
+  level = backtrace(buffer, 128);
+  stop = gettime ();
+
+  if (level <= maxlevel)
+    panic ("Unwound only %d levels, expected at least %d levels\n",
+	   level, maxlevel);
+
+  *step = (stop - start) / (double) level;
+  return 0;
+}
+
+static int f1 (int, int, double *);
+
+static int __attribute__((noinline))
+g1 (int level, int maxlevel, double *step)
+{
+  if (level == maxlevel)
+    return measure_unwind (maxlevel, step);
+  else
+    /* defeat last-call/sibcall optimization */
+    return f1 (level + 1, maxlevel, step) + level;
+}
+
+static int __attribute__((noinline))
+f1 (int level, int maxlevel, double *step)
+{
+  if (level == maxlevel)
+    return measure_unwind (maxlevel, step);
+  else
+    /* defeat last-call/sibcall optimization */
+    return g1 (level + 1, maxlevel, step) + level;
+}
+
+static void
+doit (const char *label)
+{
+  double step, min_step, first_step, sum_step;
+  int i;
+
+  sum_step = first_step = 0.0;
+  min_step = 1e99;
+  for (i = 0; i < iterations; ++i)
+    {
+      f1 (0, maxlevel, &step);
+
+      sum_step += step;
+
+      if (step < min_step)
+	min_step = step;
+
+      if (i == 0)
+	first_step = step;
+    }
+  printf ("%s: unw_step : 1st=%9.3f min=%9.3f avg=%9.3f nsec\n", label,
+	  1e9*first_step, 1e9*min_step, 1e9*sum_step/iterations);
+}
+
+static long
+sum (void *buf, size_t size)
+{
+  long s = 0;
+  char *cp = buf;
+  size_t i;
+
+  for (i = 0; i < size; i += 8)
+    s += cp[i];
+  return s;
+}
+
+static void
+measure_init (void)
+{
+# define N	100
+# define M	10	/* must be at least 2 to get steady-state */
+  double stop, start, get_cold, get_warm, init_cold, init_warm, delta;
+  struct
+    {
+      unw_cursor_t c;
+      char padding[1024];	/* should be > 2 * max. cacheline size */
+    }
+  cursor[N];
+  struct
+    {
+      unw_context_t uc;
+      char padding[1024];	/* should be > 2 * max. cacheline size */
+    }
+  uc[N];
+  int i, j;
+
+  /* Run each test M times and take the minimum to filter out noise
+     such dynamic linker resolving overhead, context-switches,
+     page-in, cache, and TLB effects.  */
+
+  get_cold = 1e99;
+  for (j = 0; j < M; ++j)
+    {
+      dummy += sum (big, sizeof (big));			/* flush the cache */
+      for (i = 0; i < N; ++i)
+	uc[i].padding[511] = i;		/* warm up the TLB */
+      start = gettime ();
+      for (i = 0; i < N; ++i)
+	unw_getcontext (&uc[i].uc);
+      stop = gettime ();
+      delta = (stop - start) / N;
+      if (delta < get_cold)
+	get_cold = delta;
+    }
+
+  init_cold = 1e99;
+  for (j = 0; j < M; ++j)
+    {
+      dummy += sum (big, sizeof (big));	/* flush cache */
+      for (i = 0; i < N; ++i)
+	uc[i].padding[511] = i;		/* warm up the TLB */
+      start = gettime ();
+      for (i = 0; i < N; ++i)
+	unw_init_local (&cursor[i].c, &uc[i].uc);
+      stop = gettime ();
+      delta = (stop - start) / N;
+      if (delta < init_cold)
+	init_cold = delta;
+    }
+
+  get_warm = 1e99;
+  for (j = 0; j < M; ++j)
+    {
+      start = gettime ();
+      for (i = 0; i < N; ++i)
+	unw_getcontext (&uc[0].uc);
+      stop = gettime ();
+      delta = (stop - start) / N;
+      if (delta < get_warm)
+	get_warm = delta;
+    }
+
+  init_warm = 1e99;
+  for (j = 0; j < M; ++j)
+    {
+      start = gettime ();
+      for (i = 0; i < N; ++i)
+	unw_init_local (&cursor[0].c, &uc[0].uc);
+      stop = gettime ();
+      delta = (stop - start) / N;
+      if (delta < init_warm)
+	init_warm = delta;
+    }
+
+  printf ("unw_getcontext : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
+	  1e9 * get_cold, 1e9 * get_warm);
+  printf ("unw_init_local : cold avg=%9.3f nsec, warm avg=%9.3f nsec\n",
+	  1e9 * init_cold, 1e9 * init_warm);
+}
+
+int
+main (int argc, char **argv)
+{
+  struct rlimit rlim;
+
+  rlim.rlim_cur = RLIM_INFINITY;
+  rlim.rlim_max = RLIM_INFINITY;
+  setrlimit (RLIMIT_STACK, &rlim);
+
+  memset (big, 0xaa, sizeof (big));
+
+  if (argc > 1)
+    {
+      maxlevel = atol (argv[1]);
+      if (argc > 2)
+	iterations = atol (argv[2]);
+    }
+
+  measure_init ();
+
+  unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_NONE);
+  doit ("no cache        ");
+
+  unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_GLOBAL);
+  doit ("global cache    ");
+
+  unw_set_caching_policy (unw_local_addr_space, UNW_CACHE_PER_THREAD);
+  doit ("per-thread cache");
+
+  return 0;
+}

tests/Lperf-trace.c

@@ -0,0 +1,5 @@
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+#if !defined(UNW_REMOTE_ONLY)
+#include "Gperf-trace.c"
+#endif

tests/Makefile.am

@@ -46,17 +46,20 @@ endif #ARCH_IA64
 			test-mem test-setjmp test-ptrace		 \
 			Ltest-nomalloc rs-race
  noinst_PROGRAMS_cdep = forker mapper test-ptrace-misc test-varargs	\
-			Gperf-simple Lperf-simple
+			Gperf-simple Lperf-simple			\
+			Gperf-trace Lperf-trace
 
 if SUPPORT_CXX_EXCEPTIONS
  check_PROGRAMS_cdep += Ltest-cxx-exceptions
 endif
 
-perf: perf-startup Gperf-simple Lperf-simple
+perf: perf-startup Gperf-simple Lperf-simple Lperf-trace
 	@echo "########## Basic performance of generic libunwind:"
 	@./Gperf-simple
 	@echo "########## Basic performance of local-only libunwind:"
 	@./Lperf-simple
+	@echo "########## Performance of fast unwind:"
+	@./Lperf-trace
 	@echo "########## Startup overhead:"
 	@$(srcdir)/perf-startup @arch@
 
@@ -137,6 +140,7 @@ Gtest_init_LDADD = $(LIBUNWIND)
 Gtest_resume_sig_LDADD = $(LIBUNWIND)
 Gperf_simple_LDADD = $(LIBUNWIND)
 Gtest_trace_LDADD=$(LIBUNWIND)
+Gperf_trace_LDADD = $(LIBUNWIND)
 
 Ltest_bt_LDADD = $(LIBUNWIND_local)
 Ltest_concurrent_LDADD = $(LIBUNWIND_local) -lpthread
@@ -147,6 +151,7 @@ Ltest_nomalloc_LDADD = $(LIBUNWIND_local) @DLLIB@
 Ltest_resume_sig_LDADD = $(LIBUNWIND)
 Lperf_simple_LDADD = $(LIBUNWIND_local)
 Ltest_trace_LDADD = $(LIBUNWIND_local)
+Lperf_trace_LDADD = $(LIBUNWIND_local)
 
 test_setjmp_LDADD = $(LIBUNWIND_setjmp)
 ia64_test_setjmp_LDADD = $(LIBUNWIND_setjmp)