[libcxxabi] Refactor test timing logic and disable by default.

[EricWF]

Summary

When using LIT the timing output is entirely unused but introduces a dependency on <chrono>. When libc++ is built without a montonic clock this causes some of the tests to fail.
This patch factors out all of the timing logic into support/timer.hpp and disables it by default. To enable the timing you must define LIBCXXABI_TIME_TESTS.

[jroelofs]

These are still useful to make sure we don't regress too badly on typeinfo lookup performance, so I think we should default this to 'on'.

Then we can turn it off in the configurations where it makes for unnecessary failures (like on my baremetal stuff where there isn't a monotonic clock).

It is a bit lame that we don't have a way to automatically catch changes in the perf numbers that come out of this though. Any ideas on how to fix that?

[EricWF]

In D6391#4, @jroelofs wrote:

These are still useful to make sure we don't regress too badly on typeinfo lookup performance, so I think we should default this to 'on'.

Then we can turn it off in the configurations where it makes for unnecessary failures (like on my baremetal stuff where there isn't a monotonic clock).

Sounds good. I'll make the change.

It is a bit lame that we don't have a way to automatically catch changes in the perf numbers that come out of this though. Any ideas on how to fix that?

Yes. Once the suffix test patch gets through review I'm going to start working on something. I actually have an internship starting in January to solve exactly this problem.

[EricWF]

Somewhat address @jroelofs comments. The timers are enabled by default EXCEPT when using LIT. Since there is currently no way in LIT to show the output it doesn't make sense to introduce the <chrono> dependency.

[jroelofs]

LGTM

test/test_demangle.cpp

15

I think this include should go at the top.

test/dynamic_cast14.cpp

 //===----------------------------------------------------------------------===//
 
 #include <cassert>
+#include "support/timer.hpp"
 
 namespace t1
 {

 
 }  // t3
 
-#include <chrono>
-#include <iostream>
-
 int main()
 {
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef Clock::time_point time_point;
-    typedef std::chrono::duration<double, std::micro> NS;
-    time_point t0 = Clock::now();
+    timer t;
     t1::test();
     t2::test();
     t3::test();
-    time_point t1 = Clock::now();
-    std::cout << NS(t1-t0).count() << " microseconds\n";
 }

test/dynamic_cast3.cpp

 //===----------------------------------------------------------------------===//
 
 #include <cassert>
+#include "support/timer.hpp"
 
 /*
 

 
 }  // t41
 
-#include <chrono>
-#include <iostream>
-
 int main()
 {
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef Clock::time_point time_point;
-    typedef std::chrono::duration<double, std::micro> NS;
-    time_point t0 = Clock::now();
+    timer t;
     t1::test();
     t2::test();
     t3::test();

     t39::test();
     t40::test();
     t41::test();
-    time_point t1 = Clock::now();
-    std::cout << NS(t1-t0).count() << " microseconds\n";
 }

test/dynamic_cast5.cpp

 //===----------------------------------------------------------------------===//
 
 #include <cassert>
+#include "support/timer.hpp"
 
 namespace t1
 {

 
 }  // t9
 
-#include <chrono>
-#include <iostream>
 
 int main()
 {
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef Clock::time_point time_point;
-    typedef std::chrono::duration<double, std::micro> NS;
-    time_point t0 = Clock::now();
+    timer t;
     t1::test();
     t2::test();
     t3::test();

     t7::test();
     t8::test();
     t9::test();
-    time_point t1 = Clock::now();
-    std::cout << NS(t1-t0).count() << " microseconds\n";
 }

test/dynamic_cast_stress.cpp

 
 #include <cassert>
 #include <tuple>
-#include <chrono>
-#include <iostream>
+#include "support/timer.hpp"
 
 template <std::size_t Indx, std::size_t Depth>
 struct C

 
 void test()
 {
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef std::chrono::duration<double, std::micro> US;
     const std::size_t Width = 10;
     const std::size_t Depth = 5;
     A<Width, Depth> a;
     typedef B<Width/2, Depth> Destination;
 //    typedef A<Width, Depth> Destination;
-    auto t0 = Clock::now();
-    Destination* b = dynamic_cast<Destination*>((C<Width/2, 0>*)&a);
-    auto t1 = Clock::now();
-    std::cout << US(t1-t0).count() << " microseconds\n";
+    Destination *b = nullptr;
+    {
+        timer t;
+        b = dynamic_cast<Destination*>((C<Width/2, 0>*)&a);
+    }
     assert(b != 0);
 }
 

test/lit.cfg

 
 # Configure extra compiler flags.
 
+# Always disable timed test when using LIT since the output gets lost and since
+# using the timer requires <chrono> as a dependancy.
+compile_flags += ['-DLIBCXXABI_NO_TIMER']
+
 san = lit_config.params.get('llvm_use_sanitizer', None)
 if san is None:
     san = getattr(config, 'llvm_use_sanitizer', None)

test/support/timer.hpp

+#ifndef TIMER_HPP
+#define TIMER_HPP
+
+// Define LIBCXXABI_NO_TIMER to disable testing with a timer.
+#ifndef LIBCXXABI_NO_TIMER
+
+#include <chrono>
+#include <iostream>
+
+class timer
+{
+    typedef std::chrono::high_resolution_clock Clock;
+    typedef Clock::time_point TimePoint;
+    typedef std::chrono::microseconds MicroSeconds;
+public:
+    timer() : m_start(Clock::now()) {}
+
+    timer(timer const &) = delete;
+    timer & operator=(timer const &) = delete;
+
+    ~timer()
+    {
+        using std::chrono::duration_cast;
+        TimePoint end = Clock::now();
+        MicroSeconds us = duration_cast<MicroSeconds>(end - m_start);
+        std::cout << us.count() << " microseconds\n";
+    }
+
+private:
+    TimePoint m_start;
+};
+
+#else /* LIBCXXABI_NO_TIMER */
+
+class timer
+{
+public:
+    timer() {}
+    timer(timer const &) = delete;
+    timer & operator=(timer const &) = delete;
+    ~timer() {}
+};
+
+#endif /* LIBCXXABI_TIME_TESTS */
+
+#endif /* TIMER_HPP */
 No newline at end of file

test/test_demangle.cpp

 #include <cstdlib>
 #include <cxxabi.h>
 #include <cassert>
-#include <chrono>
+#include "support/timer.hpp"
 
 // Is long double fp80?  (Only x87 extended double has 64-bit mantissa)
 #define LDBL_FP80 (__LDBL_MANT_DIG__ == 64)

 
 int main()
 {
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef std::chrono::duration<double> sec;
-    Clock::time_point t0 = Clock::now();
+    std::cout << "Testing " << N << " symbols." << std::endl;
+    {
+        timer t;
         test();
         test2();
-    Clock::time_point t1 = Clock::now();
-    std::cout << sec(t1-t0).count() << " seconds for test\n";
-    std::cout << N / sec(t1-t0).count() / 1000000. << " million symbols per second\n";
+    }
 #if 0
     std::string input;
     while (std::cin)