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

new dynamic cast benches

Browse Source
This commit is contained in:
BlackMATov
2023-12-27 22:55:40 +07:00
parent 004a957507
commit d181a6b8a9
2 changed files with 163 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
develop/unbench/cast_function_bench.cpp
View File

@@ -24,21 +24,22 @@ namespace
base1(const base1&) = default; base1(const base1&) = default;
base1& operator=(const base1&) = default; base1& operator=(const base1&) = default;
META_HPP_ENABLE_POLY_INFO()
}; };
struct base2 : base1 { struct base2 : base1 {
unsigned b2{2}; unsigned b2{2};
META_HPP_ENABLE_BASE_INFO(base1) META_HPP_ENABLE_POLY_INFO(base1)
}; };
struct base3 : base2 { struct base3 : base2 {
unsigned b3{3}; unsigned b3{3};
META_HPP_ENABLE_BASE_INFO(base2) META_HPP_ENABLE_POLY_INFO(base2)
}; };
struct base4 : base3 { struct base4 : base3 {
unsigned b4{4}; unsigned b4{4};
META_HPP_ENABLE_BASE_INFO(base3) META_HPP_ENABLE_POLY_INFO(base3)
}; };
unsigned static_function_1(base1* b1) { unsigned static_function_1(base1* b1) {

234
develop/unbench/dynamic_cast_bench.cpp
View File

@@ -14,144 +14,228 @@ namespace
namespace meta = meta_hpp; namespace meta = meta_hpp;
namespace vmath = vmath_hpp; namespace vmath = vmath_hpp;
struct base1 { template < typename To, typename From >
unsigned b1{1}; To* dyn_cast(From* from) {
return dynamic_cast<To*>(from);
base1() = default; }
virtual ~base1() = default; }
base1(const base1&) = default;
base1& operator=(const base1&) = default;
namespace
{
struct A1 {
META_HPP_ENABLE_POLY_INFO() META_HPP_ENABLE_POLY_INFO()
}; };
struct base2 : base1 { struct B1 : A1 {
unsigned b2{2}; META_HPP_ENABLE_POLY_INFO(A1)
META_HPP_ENABLE_POLY_INFO(base1)
}; };
struct base3 : base2 { struct C1 : B1 {
unsigned b3{3}; META_HPP_ENABLE_POLY_INFO(B1)
META_HPP_ENABLE_POLY_INFO(base2)
}; };
struct base4 : base3 { // A1 < B1 < C1
unsigned b4{4};
META_HPP_ENABLE_POLY_INFO(base3)
};
base4* dynamic_cast_1(base1* b1) { [[maybe_unused]]
return dynamic_cast<base4*>(b1); void dynamic_cast_1a(benchmark::State &state) {
C1 c;
for ( auto _ : state ) {
A1* a = &c;
C1* cc = dyn_cast<C1>(a);
benchmark::DoNotOptimize(cc);
}
} }
base4* dynamic_cast_2(base2* b2) { [[maybe_unused]]
return dynamic_cast<base4*>(b2); void meta_dynamic_cast_1a(benchmark::State &state) {
C1 c;
for ( auto _ : state ) {
A1* a = &c;
C1* cc = meta::ucast<C1*>(a);
benchmark::DoNotOptimize(cc);
}
} }
base4* dynamic_cast_3(base3* b3) { [[maybe_unused]]
return dynamic_cast<base4*>(b3); void dynamic_cast_1b(benchmark::State &state) {
C1 c;
for ( auto _ : state ) {
A1* a = &c;
B1* b = dyn_cast<B1>(a);
benchmark::DoNotOptimize(b);
}
} }
base4* dynamic_cast_4(base4* b4) { [[maybe_unused]]
return dynamic_cast<base4*>(b4); void meta_dynamic_cast_1b(benchmark::State &state) {
C1 c;
for ( auto _ : state ) {
A1* a = &c;
B1* b = meta::ucast<B1*>(a);
benchmark::DoNotOptimize(b);
}
} }
} }
// BENCHMARK(dynamic_cast_1a);
// native BENCHMARK(meta_dynamic_cast_1a);
// BENCHMARK(dynamic_cast_1b);
BENCHMARK(meta_dynamic_cast_1b);
namespace namespace
{ {
struct A2 {
META_HPP_ENABLE_POLY_INFO()
};
struct B2 {
META_HPP_ENABLE_POLY_INFO()
};
struct C2 : A2, B2 {
META_HPP_ENABLE_POLY_INFO(A2, B2)
};
struct D2 : C2 {
META_HPP_ENABLE_POLY_INFO(C2)
};
// A2
// < C2 < D2
// B2
[[maybe_unused]] [[maybe_unused]]
void dynamic_cast_1(benchmark::State &state) { void dynamic_cast_2a(benchmark::State &state) {
base4 b4; D2 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = dynamic_cast_1(&b4); A2* a = &d;
benchmark::DoNotOptimize(r); D2* dd = dyn_cast<D2>(a);
benchmark::DoNotOptimize(dd);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void dynamic_cast_2(benchmark::State &state) { void meta_dynamic_cast_2a(benchmark::State &state) {
base4 b4; D2 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = dynamic_cast_2(&b4); A2* a = &d;
benchmark::DoNotOptimize(r); D2* dd = meta::ucast<D2*>(a);
benchmark::DoNotOptimize(dd);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void dynamic_cast_3(benchmark::State &state) { void dynamic_cast_2b(benchmark::State &state) {
base4 b4; D2 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = dynamic_cast_3(&b4); B2* b = &d;
benchmark::DoNotOptimize(r); C2* c = dyn_cast<C2>(b);
benchmark::DoNotOptimize(c);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void dynamic_cast_4(benchmark::State &state) { void meta_dynamic_cast_2b(benchmark::State &state) {
base4 b4; D2 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = dynamic_cast_4(&b4); B2* b = &d;
benchmark::DoNotOptimize(r); C2* c = meta::ucast<C2*>(b);
benchmark::DoNotOptimize(c);
} }
} }
} }
// BENCHMARK(dynamic_cast_2a);
// meta BENCHMARK(meta_dynamic_cast_2a);
// BENCHMARK(dynamic_cast_2b);
BENCHMARK(meta_dynamic_cast_2b);
namespace namespace
{ {
struct A3 {
META_HPP_ENABLE_POLY_INFO()
};
struct B3 : virtual A3 {
META_HPP_ENABLE_POLY_INFO(A3)
};
struct C3 : virtual A3 {
META_HPP_ENABLE_POLY_INFO(A3)
};
struct D3 : B3, C3 {
META_HPP_ENABLE_POLY_INFO(B3, C3)
};
// A3 <= B3
// < D3
// A3 <= C3
[[maybe_unused]] [[maybe_unused]]
void meta_dynamic_cast_1(benchmark::State &state) { void dynamic_cast_3a(benchmark::State &state) {
base4 b4; D3 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = meta::ucast<base4*>(static_cast<base1*>(&b4)); A3* a = &d;
benchmark::DoNotOptimize(r); D3* dd = dyn_cast<D3>(a);
benchmark::DoNotOptimize(dd);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void meta_dynamic_cast_2(benchmark::State &state) { void meta_dynamic_cast_3a(benchmark::State &state) {
base4 b4; D3 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = meta::ucast<base4*>(static_cast<base2*>(&b4)); A3* a = &d;
benchmark::DoNotOptimize(r); D3* dd = meta::ucast<D3*>(a);
benchmark::DoNotOptimize(dd);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void meta_dynamic_cast_3(benchmark::State &state) { void dynamic_cast_3b(benchmark::State &state) {
base4 b4; D3 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = meta::ucast<base4*>(static_cast<base3*>(&b4)); B3* b = &d;
benchmark::DoNotOptimize(r); C3* c = dyn_cast<C3>(b);
benchmark::DoNotOptimize(c);
} }
} }
[[maybe_unused]] [[maybe_unused]]
void meta_dynamic_cast_4(benchmark::State &state) { void meta_dynamic_cast_3b(benchmark::State &state) {
base4 b4; D3 d;
for ( auto _ : state ) { for ( auto _ : state ) {
base4* r = meta::ucast<base4*>(static_cast<base4*>(&b4)); B3* b = &d;
benchmark::DoNotOptimize(r); C3* c = meta::ucast<C3*>(b);
benchmark::DoNotOptimize(c);
}
}
[[maybe_unused]]
void dynamic_cast_3c(benchmark::State &state) {
B3 b;
for ( auto _ : state ) {
A3* a = &b;
C3* c = dyn_cast<C3>(a);
benchmark::DoNotOptimize(c);
}
}
[[maybe_unused]]
void meta_dynamic_cast_3c(benchmark::State &state) {
B3 b;
for ( auto _ : state ) {
A3* a = &b;
C3* c = meta::ucast<C3*>(a);
benchmark::DoNotOptimize(c);
} }
} }
} }
BENCHMARK(dynamic_cast_1); BENCHMARK(dynamic_cast_3a);
BENCHMARK(meta_dynamic_cast_1); BENCHMARK(meta_dynamic_cast_3a);
BENCHMARK(dynamic_cast_3b);
BENCHMARK(dynamic_cast_2); BENCHMARK(meta_dynamic_cast_3b);
BENCHMARK(meta_dynamic_cast_2); BENCHMARK(dynamic_cast_3c);
BENCHMARK(meta_dynamic_cast_3c);
BENCHMARK(dynamic_cast_3);
BENCHMARK(meta_dynamic_cast_3);
BENCHMARK(dynamic_cast_4);
BENCHMARK(meta_dynamic_cast_4);