diff --git a/tests/Gperf-trace.c b/tests/Gperf-trace.c new file mode 100644 index 00000000..73207027 --- /dev/null +++ b/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 + +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 +#include +#include +#include + +#include + +#include +#include + +#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; +} diff --git a/tests/Lperf-trace.c b/tests/Lperf-trace.c new file mode 100644 index 00000000..1c3cf21c --- /dev/null +++ b/tests/Lperf-trace.c @@ -0,0 +1,5 @@ +#define UNW_LOCAL_ONLY +#include +#if !defined(UNW_REMOTE_ONLY) +#include "Gperf-trace.c" +#endif diff --git a/tests/Makefile.am b/tests/Makefile.am index aebe1296..c724e438 100644 --- a/tests/Makefile.am +++ b/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)