add rttr for bench

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "develop/vendors/vmath.hpp"]
 	path = develop/vendors/vmath.hpp
 	url = https://github.com/BlackMATov/vmath.hpp
+[submodule "develop/vendors/rttr"]
+	path = develop/vendors/rttr
+	url = https://github.com/rttrorg/rttr

develop/unbench/CMakeLists.txt

@@ -10,12 +10,14 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
     meta.hpp::meta.hpp
     meta.hpp::setup_targets
     meta.hpp.vendors::gbench
+    meta.hpp.vendors::rttr
     meta.hpp.vendors::vmath.hpp)
 
 target_link_libraries(${PROJECT_NAME}.singles PRIVATE
     meta.hpp::singles
     meta.hpp::setup_targets
     meta.hpp.vendors::gbench
+    meta.hpp.vendors::rttr
     meta.hpp.vendors::vmath.hpp)
 
 add_test(${PROJECT_NAME} ${PROJECT_NAME})

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);

develop/vendors/CMakeLists.txt

@@ -55,7 +55,29 @@ target_compile_definitions(${PROJECT_NAME}.gbench
     PUBLIC BENCHMARK_STATIC_DEFINE)
 
 #
-# vmath
+# rttr
+#
+
+file(GLOB_RECURSE RTTR_SOURCES CONFIGURE_DEPENDS "rttr/src/rttr/*.cpp")
+add_library(${PROJECT_NAME}.rttr STATIC ${RTTR_SOURCES})
+add_library(${PROJECT_NAME}::rttr ALIAS ${PROJECT_NAME}.rttr)
+
+target_compile_features(${PROJECT_NAME}.rttr
+    PUBLIC cxx_std_20)
+
+target_include_directories(${PROJECT_NAME}.rttr SYSTEM
+    PUBLIC rttr/src)
+
+configure_file(
+    "rttr/src/rttr/detail/base/version.h.in"
+    "generated/vendors/rttr/rttr/detail/base/version.h"
+    @ONLY)
+
+target_include_directories(${PROJECT_NAME}.rttr SYSTEM
+    PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/generated/vendors/rttr")
+
+#
+# vmath.hpp
 #
 
 add_library(${PROJECT_NAME}.vmath.hpp INTERFACE)