add rttr for bench

develop/unbench/invoke_function_bench.cpp

@@ -7,6 +7,7 @@
 #include <meta.hpp/meta_all.hpp>
 
 #include <benchmark/benchmark.h>
+#include <rttr/registration>
 #include <vmath.hpp/vmath_all.hpp>
 
 namespace
@@ -14,8 +15,8 @@ namespace
     namespace meta = meta_hpp;
     namespace vmath = vmath_hpp;
 
+    float static_angle{};
     volatile float static_acc{};
-    volatile float static_angle{};
 
     struct clazz {
         static void static_function0() {
@@ -44,63 +45,118 @@ namespace
         static_angle = 0.f;
     }
 
-    void invoke_function_static0(benchmark::State &state) {
+    // native
+
+    void invoke_function_0(benchmark::State &state) {
         for ( auto _ : state ) {
             clazz::static_function0();
         }
     }
 
-    void invoke_function_static1(benchmark::State &state) {
+    void invoke_function_1(benchmark::State &state) {
         for ( auto _ : state ) {
             clazz::static_function1(static_angle);
         }
     }
 
-    void invoke_function_static2(benchmark::State &state) {
+    void invoke_function_2(benchmark::State &state) {
         for ( auto _ : state ) {
             clazz::static_function2(static_angle, vmath::unit3_x<float>);
         }
     }
 
-    void invoke_function_static3(benchmark::State &state) {
+    void invoke_function_3(benchmark::State &state) {
         for ( auto _ : state ) {
             clazz::static_function3(static_angle, vmath::unit3_x<float>, 2.f);
         }
     }
 
-    void invoke_function_dynamic0(benchmark::State &state) {
+    // meta
+
+    void meta_invoke_function_0(benchmark::State &state) {
         for ( auto _ : state ) {
             meta::invoke(&clazz::static_function0);
         }
     }
 
-    void invoke_function_dynamic1(benchmark::State &state) {
+    void meta_invoke_function_1(benchmark::State &state) {
         for ( auto _ : state ) {
             meta::invoke(&clazz::static_function1, static_angle);
         }
     }
 
-    void invoke_function_dynamic2(benchmark::State &state) {
+    void meta_invoke_function_2(benchmark::State &state) {
         for ( auto _ : state ) {
             meta::invoke(&clazz::static_function2, static_angle, vmath::unit3_x<float>);
         }
     }
 
-    void invoke_function_dynamic3(benchmark::State &state) {
+    void meta_invoke_function_3(benchmark::State &state) {
         for ( auto _ : state ) {
             meta::invoke(&clazz::static_function3, static_angle, vmath::unit3_x<float>, 2.f);
         }
     }
+
+    // rttr
+
+    void rttr_invoke_function_0(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_0");
+        META_HPP_ASSERT(m.is_valid());
+
+        for ( auto _ : state ) {
+            m.invoke({});
+        }
+    }
+
+    void rttr_invoke_function_1(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_1");
+        META_HPP_ASSERT(m.is_valid());
+
+        for ( auto _ : state ) {
+            m.invoke({}, static_angle);
+        }
+    }
+
+    void rttr_invoke_function_2(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_2");
+        META_HPP_ASSERT(m.is_valid());
+
+        for ( auto _ : state ) {
+            m.invoke({}, static_angle, vmath::unit3_x<float>);
+        }
+    }
+
+    void rttr_invoke_function_3(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_3");
+        META_HPP_ASSERT(m.is_valid());
+
+        for ( auto _ : state ) {
+            m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f);
+        }
+    }
 }
 
-BENCHMARK(invoke_function_static0)->Teardown(invoke_function_reset);
-BENCHMARK(invoke_function_dynamic0)->Teardown(invoke_function_reset);
+RTTR_REGISTRATION
+{
+    using namespace rttr;
+    registration::method("rttr_invoke_function_0", &clazz::static_function0);
+    registration::method("rttr_invoke_function_1", &clazz::static_function1);
+    registration::method("rttr_invoke_function_2", &clazz::static_function2);
+    registration::method("rttr_invoke_function_3", &clazz::static_function3);
+}
 
-BENCHMARK(invoke_function_static1)->Teardown(invoke_function_reset);
-BENCHMARK(invoke_function_dynamic1)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_0)->Teardown(invoke_function_reset);
+BENCHMARK(meta_invoke_function_0)->Teardown(invoke_function_reset);
+BENCHMARK(rttr_invoke_function_0)->Teardown(invoke_function_reset);
 
-BENCHMARK(invoke_function_static2)->Teardown(invoke_function_reset);
-BENCHMARK(invoke_function_dynamic2)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_1)->Teardown(invoke_function_reset);
+BENCHMARK(meta_invoke_function_1)->Teardown(invoke_function_reset);
+BENCHMARK(rttr_invoke_function_1)->Teardown(invoke_function_reset);
 
-BENCHMARK(invoke_function_static3)->Teardown(invoke_function_reset);
-BENCHMARK(invoke_function_dynamic3)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_2)->Teardown(invoke_function_reset);
+BENCHMARK(meta_invoke_function_2)->Teardown(invoke_function_reset);
+BENCHMARK(rttr_invoke_function_2)->Teardown(invoke_function_reset);
+
+BENCHMARK(invoke_function_3)->Teardown(invoke_function_reset);
+BENCHMARK(meta_invoke_function_3)->Teardown(invoke_function_reset);
+BENCHMARK(rttr_invoke_function_3)->Teardown(invoke_function_reset);