BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-13 19:18:01 +07:00
Code Issues Packages Projects Releases Wiki Activity

bench: invoke_4

Browse Source
This commit is contained in:
BlackMATov
2023-02-13 16:42:09 +07:00
parent b25fe5c6b0
commit c15b5aa50d
1 changed files with 138 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
develop/unbench/invoke_function_bench.cpp
View File

@@ -5,10 +5,12 @@
******************************************************************************/ ******************************************************************************/
#include <meta.hpp/meta_all.hpp> #include <meta.hpp/meta_all.hpp>
#include <vmath.hpp/vmath_all.hpp>
#include <rttr/type>
#include <rttr/registration>
#include <benchmark/benchmark.h> #include <benchmark/benchmark.h>
#include <rttr/registration>
#include <vmath.hpp/vmath_all.hpp>
namespace namespace
{ {
@@ -18,89 +20,161 @@ namespace
float static_angle{}; float static_angle{};
volatile float static_acc{}; volatile float static_acc{};
struct clazz { void static_function_0() {
static void static_function0() { static_acc = static_acc + vmath::determinant(vmath::rotate(static_angle, vmath::unit3_x<float>));
static_acc = static_acc + vmath::determinant(vmath::rotate(static_angle, vmath::unit3_x<float>)); static_angle = static_angle + 0.00001f;
static_angle = static_angle + 0.00001f; }
}
static void static_function1(float angle) { void static_function_1(float angle) {
static_acc = static_acc + vmath::determinant(vmath::rotate(angle, vmath::unit3_x<float>)); static_acc = static_acc + vmath::determinant(vmath::rotate(angle, vmath::unit3_x<float>));
static_angle = static_angle + 0.00001f; static_angle = static_angle + 0.00001f;
} }
static void static_function2(float angle, const vmath::fvec3& axis) { void static_function_2(float angle, const vmath::fvec3& axis) {
static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis)); static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis));
static_angle = static_angle + 0.00001f; static_angle = static_angle + 0.00001f;
} }
static void static_function3(float angle, const vmath::fvec3& axis, float mul) { void static_function_3(float angle, const vmath::fvec3& axis, float mul) {
static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis)) * mul; static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis)) * mul;
static_angle = static_angle + 0.00001f; static_angle = static_angle + 0.00001f;
} }
};
void invoke_function_reset(const benchmark::State&) { void static_function_4(float angle, const vmath::fvec3& axis, float mul, const vmath::fmat3& mat) {
static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis) * mat) * mul;
static_angle = static_angle + 0.00001f;
}
void static_function_reset(const benchmark::State&) {
static_acc = 0.f; static_acc = 0.f;
static_angle = 0.f; static_angle = 0.f;
} }
// native meta::scope meta_bench_scope = meta::local_scope_("")
.function_("static_function_0", &static_function_0)
.function_("static_function_1", &static_function_1)
.function_("static_function_2", &static_function_2)
.function_("static_function_3", &static_function_3)
.function_("static_function_4", &static_function_4);
}
RTTR_REGISTRATION
{
using namespace rttr;
registration::method("static_function_0", &static_function_0);
registration::method("static_function_1", &static_function_1);
registration::method("static_function_2", &static_function_2);
registration::method("static_function_3", &static_function_3);
registration::method("static_function_4", &static_function_4);
}
//
// native
//
namespace
{
[[maybe_unused]]
void invoke_function_0(benchmark::State &state) { void invoke_function_0(benchmark::State &state) {
for ( auto _ : state ) { for ( auto _ : state ) {
clazz::static_function0(); static_function_0();
} }
} }
[[maybe_unused]]
void invoke_function_1(benchmark::State &state) { void invoke_function_1(benchmark::State &state) {
for ( auto _ : state ) { for ( auto _ : state ) {
clazz::static_function1(static_angle); static_function_1(static_angle);
} }
} }
[[maybe_unused]]
void invoke_function_2(benchmark::State &state) { void invoke_function_2(benchmark::State &state) {
for ( auto _ : state ) { for ( auto _ : state ) {
clazz::static_function2(static_angle, vmath::unit3_x<float>); static_function_2(static_angle, vmath::unit3_x<float>);
} }
} }
[[maybe_unused]]
void invoke_function_3(benchmark::State &state) { void invoke_function_3(benchmark::State &state) {
for ( auto _ : state ) { for ( auto _ : state ) {
clazz::static_function3(static_angle, vmath::unit3_x<float>, 2.f); static_function_3(static_angle, vmath::unit3_x<float>, 2.f);
} }
} }
// meta [[maybe_unused]]
void invoke_function_4(benchmark::State &state) {
for ( auto _ : state ) {
static_function_4(static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
}
}
}
//
// meta
//
namespace
{
[[maybe_unused]]
void meta_invoke_function_0(benchmark::State &state) { void meta_invoke_function_0(benchmark::State &state) {
meta::function f = meta_bench_scope.get_function("static_function_0");
for ( auto _ : state ) { for ( auto _ : state ) {
meta::invoke(&clazz::static_function0); f();
} }
} }
[[maybe_unused]]
void meta_invoke_function_1(benchmark::State &state) { void meta_invoke_function_1(benchmark::State &state) {
meta::function f = meta_bench_scope.get_function("static_function_1");
META_HPP_ASSERT(f.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
meta::invoke(&clazz::static_function1, static_angle); f(static_angle);
} }
} }
[[maybe_unused]]
void meta_invoke_function_2(benchmark::State &state) { void meta_invoke_function_2(benchmark::State &state) {
meta::function f = meta_bench_scope.get_function("static_function_2");
META_HPP_ASSERT(f.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
meta::invoke(&clazz::static_function2, static_angle, vmath::unit3_x<float>); f(static_angle, vmath::unit3_x<float>);
} }
} }
[[maybe_unused]]
void meta_invoke_function_3(benchmark::State &state) { void meta_invoke_function_3(benchmark::State &state) {
meta::function f = meta_bench_scope.get_function("static_function_3");
META_HPP_ASSERT(f.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
meta::invoke(&clazz::static_function3, static_angle, vmath::unit3_x<float>, 2.f); f(static_angle, vmath::unit3_x<float>, 2.f);
} }
} }
// rttr [[maybe_unused]]
void meta_invoke_function_4(benchmark::State &state) {
meta::function f = meta_bench_scope.get_function("static_function_4");
META_HPP_ASSERT(f.is_valid());
for ( auto _ : state ) {
f(static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
}
}
}
//
// rttr
//
namespace
{
[[maybe_unused]]
void rttr_invoke_function_0(benchmark::State &state) { void rttr_invoke_function_0(benchmark::State &state) {
rttr::method m = rttr::type::get_global_method("rttr_invoke_function_0"); rttr::method m = rttr::type::get_global_method("static_function_0");
META_HPP_ASSERT(m.is_valid()); META_HPP_ASSERT(m.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
@@ -108,8 +182,9 @@ namespace
} }
} }
[[maybe_unused]]
void rttr_invoke_function_1(benchmark::State &state) { void rttr_invoke_function_1(benchmark::State &state) {
rttr::method m = rttr::type::get_global_method("rttr_invoke_function_1"); rttr::method m = rttr::type::get_global_method("static_function_1");
META_HPP_ASSERT(m.is_valid()); META_HPP_ASSERT(m.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
@@ -117,8 +192,9 @@ namespace
} }
} }
[[maybe_unused]]
void rttr_invoke_function_2(benchmark::State &state) { void rttr_invoke_function_2(benchmark::State &state) {
rttr::method m = rttr::type::get_global_method("rttr_invoke_function_2"); rttr::method m = rttr::type::get_global_method("static_function_2");
META_HPP_ASSERT(m.is_valid()); META_HPP_ASSERT(m.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
@@ -126,37 +202,43 @@ namespace
} }
} }
[[maybe_unused]]
void rttr_invoke_function_3(benchmark::State &state) { void rttr_invoke_function_3(benchmark::State &state) {
rttr::method m = rttr::type::get_global_method("rttr_invoke_function_3"); rttr::method m = rttr::type::get_global_method("static_function_3");
META_HPP_ASSERT(m.is_valid()); META_HPP_ASSERT(m.is_valid());
for ( auto _ : state ) { for ( auto _ : state ) {
m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f); m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f);
} }
} }
[[maybe_unused]]
void rttr_invoke_function_4(benchmark::State &state) {
rttr::method m = rttr::type::get_global_method("static_function_4");
META_HPP_ASSERT(m.is_valid());
for ( auto _ : state ) {
m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
}
}
} }
RTTR_REGISTRATION BENCHMARK(invoke_function_0)->Teardown(static_function_reset);
{ BENCHMARK(meta_invoke_function_0)->Teardown(static_function_reset);
using namespace rttr; BENCHMARK(rttr_invoke_function_0)->Teardown(static_function_reset);
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_0)->Teardown(invoke_function_reset); BENCHMARK(invoke_function_1)->Teardown(static_function_reset);
BENCHMARK(meta_invoke_function_0)->Teardown(invoke_function_reset); BENCHMARK(meta_invoke_function_1)->Teardown(static_function_reset);
BENCHMARK(rttr_invoke_function_0)->Teardown(invoke_function_reset); BENCHMARK(rttr_invoke_function_1)->Teardown(static_function_reset);
BENCHMARK(invoke_function_1)->Teardown(invoke_function_reset); BENCHMARK(invoke_function_2)->Teardown(static_function_reset);
BENCHMARK(meta_invoke_function_1)->Teardown(invoke_function_reset); BENCHMARK(meta_invoke_function_2)->Teardown(static_function_reset);
BENCHMARK(rttr_invoke_function_1)->Teardown(invoke_function_reset); BENCHMARK(rttr_invoke_function_2)->Teardown(static_function_reset);
BENCHMARK(invoke_function_2)->Teardown(invoke_function_reset); BENCHMARK(invoke_function_3)->Teardown(static_function_reset);
BENCHMARK(meta_invoke_function_2)->Teardown(invoke_function_reset); BENCHMARK(meta_invoke_function_3)->Teardown(static_function_reset);
BENCHMARK(rttr_invoke_function_2)->Teardown(invoke_function_reset); BENCHMARK(rttr_invoke_function_3)->Teardown(static_function_reset);
BENCHMARK(invoke_function_3)->Teardown(invoke_function_reset); BENCHMARK(invoke_function_4)->Teardown(static_function_reset);
BENCHMARK(meta_invoke_function_3)->Teardown(invoke_function_reset); BENCHMARK(meta_invoke_function_4)->Teardown(static_function_reset);
BENCHMARK(rttr_invoke_function_3)->Teardown(invoke_function_reset); BENCHMARK(rttr_invoke_function_4)->Teardown(static_function_reset);