Listing 26: Switch

Eddie · Eddie · commit 4a13f5c67e95 · 2024-05-29T20:15:54.000-07:00
diff --git a/benchmark/cm/CMakeLists.txt b/benchmark/cm/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(CMB)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_executable(
+    cmb
+    main.cpp
+)
+
+target_include_directories(cmb PRIVATE "/home/eddie/git/zoo-cm/inc")
+
diff --git a/benchmark/cm/main.cpp b/benchmark/cm/main.cpp
@@ -4,6 +4,8 @@
 #include <math.h>
 #include <stdint.h>
 
+#include "variant.h"
+
 /* Some definitions necessary, they are not in the listings */
 using f32 = float;
 constexpr f32 Pi32 = M_PI;
@@ -169,15 +171,110 @@ using P = zoo::Policy<void *[2], ShapeAffordance, zoo::Destroy, zoo::Move>;
 using Shape = zoo::AnyContainer<P>;
 
 static_assert(24 == sizeof(Shape));
+struct VariantShape: zoo::Variant<square, rectangle, triangle, circle> {
+    using Base = zoo::Variant<square, rectangle, triangle, circle>;
+    using Base::Base;
+
+    f32 area() {
+        auto rv = zoo::visit<f32>(
+            [](auto &s) {
+                if constexpr (std::is_same_v<zoo::BadVariant &, decltype(s)>) {
+                    return 0.0;
+                } else {
+                    return s.AreaNP();
+                }
+            },
+            *this
+        );
+        return rv;
+    }
+};
 
-auto zooTraverse(std::vector<Shape> &s) {
+template<typename E>
+auto zooTraverse(std::vector<E> &s) {
     f32 rv = 0;
     for(auto &shape: s) {
         rv += shape.area();
     }
     return rv;
 }
 
+/* ========================================================================
+   LISTING 25
+   ======================================================================== */
+
+enum shape_type : u32
+{
+    Shape_Square,
+    Shape_Rectangle,
+    Shape_Triangle,
+    Shape_Circle,
+    
+    Shape_Count,
+};
+
+struct shape_union
+{
+    shape_type Type;
+    f32 Width;
+    f32 Height;
+};
+
+f32 GetAreaSwitch(shape_union Shape)
+{
+    f32 Result = 0.0f;
+    
+    switch(Shape.Type)
+    {
+        case Shape_Square: {Result = Shape.Width*Shape.Width;} break;
+        case Shape_Rectangle: {Result = Shape.Width*Shape.Height;} break;
+        case Shape_Triangle: {Result = 0.5f*Shape.Width*Shape.Height;} break;
+        case Shape_Circle: {Result = Pi32*Shape.Width*Shape.Width;} break;
+        
+        case Shape_Count: {} break;
+    }
+    
+    return Result;
+}
+
+/* ========================================================================
+   LISTING 26
+   ======================================================================== */
+
+f32 TotalAreaSwitch(u32 ShapeCount, shape_union *Shapes)
+{
+    f32 Accum = 0.0f;
+    
+    for(u32 ShapeIndex = 0; ShapeIndex < ShapeCount; ++ShapeIndex)
+    {
+        Accum += GetAreaSwitch(Shapes[ShapeIndex]);
+    }
+
+    return Accum;
+}
+
+f32 TotalAreaSwitch4(u32 ShapeCount, shape_union *Shapes)
+{
+    f32 Accum0 = 0.0f;
+    f32 Accum1 = 0.0f;
+    f32 Accum2 = 0.0f;
+    f32 Accum3 = 0.0f;
+    
+    ShapeCount /= 4;
+    while(ShapeCount--)
+    {
+        Accum0 += GetAreaSwitch(Shapes[0]);
+        Accum1 += GetAreaSwitch(Shapes[1]);
+        Accum2 += GetAreaSwitch(Shapes[2]);
+        Accum3 += GetAreaSwitch(Shapes[3]);
+        
+        Shapes += 4;
+    }
+    
+    f32 Result = (Accum0 + Accum1 + Accum2 + Accum3);
+    return Result;
+}
+
 int main(int argc, const char *argv[]) {
     std::random_device rd;
     std::mt19937 mersenne(rd());
@@ -208,20 +305,60 @@ int main(int argc, const char *argv[]) {
         }
         return
             benchmark(
-                zooTraverse,
+                zooTraverse<Shape>,
                 shapes
             );
     };
-    auto report = [](auto duration) {
+    auto zooVariant = [](auto &&m) {
+        std::vector<VariantShape> shapes;
+        std::uniform_int_distribution sti(0, 2);
+        std::uniform_real_distribution<float> rd(0.00001, 1.2);
+        for(int i = Count; i--; ) {
+            auto shapeTypeIndex = sti(m);
+            switch(shapeTypeIndex) {
+                case 0: shapes.emplace_back(std::in_place_index<0>, square(rd(m))); break;
+                case 1: shapes.emplace_back(std::in_place_index<1>, rectangle(rd(m), rd(m))); break;
+                case 2: shapes.emplace_back(std::in_place_index<2>, triangle(rd(m), rd(m))); break;
+                case 3: shapes.emplace_back(std::in_place_index<3>, circle(rd(m))); break;
+                default: throw std::runtime_error("Impossible shape type index");
+            }
+        }
+        return
+            benchmark(
+                zooTraverse<VariantShape>,
+                shapes
+            );
+    };
+    auto CaseyMuratoriUnion = [](auto &&m) {
+        std::vector<shape_union> shapes;
+        std::uniform_int_distribution sti(0, 2);
+        std::uniform_real_distribution<float> rd(0.00001, 1.2);
+        for(int i = Count; i--; ) {
+            auto shapeTypeIndex = sti(m);
+            shape_union element = { static_cast<shape_type>(shapeTypeIndex), rd(m), rd(m) };
+            shapes.push_back(element);
+        }
+        return
+            benchmark(
+                TotalAreaSwitch,
+                shapes.size(),
+                shapes.data()
+            );
+    };
+    auto report = [](auto duration, auto txt) {
         auto nanos = toNanoseconds(duration);
         constexpr auto Cycle = 1/3.6;
-        std::cout << nanos << ' ' << nanos/double(Count) << ' ' << nanos/Cycle/Count << ' ' << sideEffect << std::endl;
+        std::cout << nanos << ' ' << nanos/double(Count) << ' ' << nanos/Cycle/Count << ' ' << sideEffect << ' ' << txt << std::endl;
     };
     auto zte1 = zooTypeErasure(mersenne);
     auto durationVI = virtualInheritance(mersenne);
+    auto zooVar = zooVariant(mersenne);
+    auto cmSwitch = CaseyMuratoriUnion(mersenne);
     auto zte2 = zooTypeErasure(mersenne);
-    report(zte1);
-    report(durationVI);
-    report(zte2);
+    report(zte1, "ZTE 1");
+    report(durationVI, "Virtual + inheritance");
+    report(zooVar, "Zoo variant");
+    report(cmSwitch, "Casey Muratori's SWITCH");
+    report(zte2, "ZTE 2");
     return 0;
 }
diff --git a/benchmark/cm/variant.h b/benchmark/cm/variant.h
@@ -0,0 +1,174 @@
+#include <tuple>
+    // provides std::tuple_element to be able to index a pack of types,
+    // indirectly includes type traits and utility
+#include <new>
+
+namespace zoo {
+
+template<typename T>
+void swap(T &t1, T &t2) {
+    T temporary{std::move(t1)};
+    t1 = std::move(t2);
+    t2 = std::move(temporary);
+}
+
+struct Maxer {
+    int v_;
+    constexpr Maxer(int v): v_{v} {}
+    constexpr operator int() const { return v_; }
+    constexpr Maxer operator*(Maxer o) const { return v_ < o.v_ ? o.v_ : v_; }
+};
+
+template<int... Ints>
+constexpr auto Largest = int{(Maxer{0} * ... * Maxer(Ints))};
+
+template<typename... Ts>
+constexpr auto LargestSize = Largest<sizeof(Ts)...>;
+
+template<typename... Ts>
+constexpr auto LargestAlignment = Largest<alignof(Ts)...>;
+
+static_assert(sizeof(void *) == LargestSize<int, float, char, void *>, "");
+static_assert(alignof(short) == LargestAlignment<short, char, char[4]>, "");
+
+struct BadVariant {};
+
+template<int Index, typename... Ts>
+using TypeAtIndex =
+    typename std::tuple_element<Index, std::tuple<Ts..., BadVariant>>::type;
+
+template<typename R, typename Visitor, typename Var>
+R visit(Visitor &&visitor, Var &&value);
+
+template<typename... Ts>
+struct Variant {
+    constexpr static auto Count = sizeof...(Ts);
+    constexpr static auto Size = LargestSize<Ts...>;
+    constexpr static auto Alignment = LargestAlignment<Ts...>;
+    constexpr static auto NTMC =
+        std::conjunction<std::is_nothrow_move_constructible<Ts>...>::value;
+
+    alignas(Alignment) char space_[Size];
+    int typeSwitch_ = Count;
+
+    Variant() {}
+
+    Variant(const Variant &v): typeSwitch_{v.typeSwitch_} {
+        visit<void>(
+            [&](const auto &c) {
+                using Source = std::decay_t<decltype(c)>;
+                new(as<Source>()) Source{c};
+            },
+            v
+        );
+    }
+
+    Variant(Variant &&v) noexcept(NTMC): typeSwitch_{v.typeSwitch_} {
+        visit<void>(
+            [&](auto &&m) {
+                using Source = std::decay_t<decltype(m)>;
+                new(as<Source>()) Source{std::move(m)};
+            },
+            v
+        );
+        v.typeSwitch_ = Count;
+    }
+
+    template<std::size_t Ndx, typename... Args>
+    Variant(std::in_place_index_t<Ndx>, Args &&...args): typeSwitch_{Ndx} {
+        using Held = TypeAtIndex<Ndx, Ts...>;
+        new(as<Held>()) Held{std::forward<Args>(args)...};
+    }
+
+    Variant &operator=(const Variant &model) {
+        Variant copy{model};
+        swap(*this, copy);
+        return *this;
+    }
+
+    Variant &operator=(Variant &&other) noexcept(NTMC) {
+        destroy();
+        new(this) Variant{std::move(other)};
+        return *this;
+    }
+
+    ~Variant() { destroy(); }
+
+    void reset() {
+        destroy();
+        typeSwitch_ = Count;
+    }
+
+    template<typename T>
+    T *as() noexcept { return reinterpret_cast<T *>(space_); }
+
+    template<typename T>
+    const T *as() const noexcept {
+        return const_cast<Variant *>(this)->as<T>();
+    }
+
+private:
+    void destroy() {
+        visit<void>(
+            [](auto &who) {
+                using Type = std::decay_t<decltype(who)>;
+                (&who)->~Type();
+            },
+            *this
+        );
+    }
+
+};
+
+template<int Index, typename... Ts>
+auto get(Variant<Ts...> &v) ->
+    TypeAtIndex<Index, std::tuple<Ts..., BadVariant>> &
+{
+    return v.as<TypeAtIndex<Index, std::tuple<Ts..., BadVariant>>();
+}
+
+template<
+    typename R, typename Visitor, typename V,
+    int Current, typename Head, typename... Tail
+>
+struct Visit_impl {
+    static R execute(Visitor &&visitor, V &&v, int typeSwitch) {
+        switch(typeSwitch) {
+            case Current: return visitor(*v.template as<Head>());
+            default:
+                return
+                    Visit_impl<
+                        R, Visitor, V, Current + 1, Tail...
+                    >::execute(
+                        std::forward<Visitor>(visitor),
+                        std::forward<V>(v),
+                        typeSwitch
+                    );
+        }
+    }
+};
+
+template<typename R, typename Visitor, typename V, int Current>
+struct Visit_impl<R, Visitor, V, Current, BadVariant> {
+    static R execute(Visitor &&visitor, V &&v, int) {
+        return visitor(*v.template as<BadVariant>());
+    }
+};
+
+template<typename R, typename Visitor, typename Var, typename... Types>
+R visit_injected(Visitor &&visitor, Var &&v, const Variant<Types...> *) {
+    return Visit_impl<R, Visitor, Var, 0, Types..., BadVariant>::execute(
+        std::forward<Visitor>(visitor),
+        std::forward<Var>(v),
+        v.typeSwitch_
+    );
+}
+
+template<typename R, typename Visitor, typename Var>
+R visit(Visitor &&visitor, Var &&value) {
+    return visit_injected<R>(
+        std::forward<Visitor>(visitor), std::forward<Var>(value), &value
+    );
+}
+
+}
