From d181a6b8a988b6a7be1b7427dd47a6d562d3d391 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Wed, 27 Dec 2023 22:55:40 +0700
Subject: [PATCH] new dynamic cast benches

---
 develop/unbench/cast_function_bench.cpp |   7 +-
 develop/unbench/dynamic_cast_bench.cpp  | 234 ++++++++++++++++--------
 2 files changed, 163 insertions(+), 78 deletions(-)

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