[benchmark] Add traditional inheritance to benchmarks

Author: ldionne

Diff for: benchmark/storage/ctor.cpp

@@ -29,12 +29,14 @@ static void BM_ctor(benchmark::State& state) {
 template <std::size_t Bytes>
 using WithSize = std::aligned_storage_t<Bytes>;
 
+BENCHMARK_TEMPLATE(BM_ctor, inheritance_tag,         WithSize<4>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::remote_storage,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::sbo_storage<4>,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::sbo_storage<8>,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::sbo_storage<16>,   WithSize<4>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::local_storage<16>, WithSize<4>);
 
+BENCHMARK_TEMPLATE(BM_ctor, inheritance_tag,         WithSize<16>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::remote_storage,    WithSize<16>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::sbo_storage<4>,    WithSize<16>);
 BENCHMARK_TEMPLATE(BM_ctor, dyno::sbo_storage<8>,    WithSize<16>);

Diff for: benchmark/storage/ctor.move.cpp

@@ -30,12 +30,14 @@ static void BM_move(benchmark::State& state) {
 template <std::size_t Bytes>
 using WithSize = std::aligned_storage_t<Bytes>;
 
+BENCHMARK_TEMPLATE(BM_move, inheritance_tag,         WithSize<4>);
 BENCHMARK_TEMPLATE(BM_move, dyno::remote_storage,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_move, dyno::sbo_storage<4>,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_move, dyno::sbo_storage<8>,    WithSize<4>);
 BENCHMARK_TEMPLATE(BM_move, dyno::sbo_storage<16>,   WithSize<4>);
 BENCHMARK_TEMPLATE(BM_move, dyno::local_storage<16>, WithSize<4>);
 
+BENCHMARK_TEMPLATE(BM_move, inheritance_tag,         WithSize<16>);
 BENCHMARK_TEMPLATE(BM_move, dyno::remote_storage,    WithSize<16>);
 BENCHMARK_TEMPLATE(BM_move, dyno::sbo_storage<4>,    WithSize<16>);
 BENCHMARK_TEMPLATE(BM_move, dyno::sbo_storage<8>,    WithSize<16>);

Diff for: benchmark/storage/dispatch.many.cpp

@@ -30,9 +30,9 @@ static void BM_dispatch_many(benchmark::State& state) {
   benchmark::DoNotOptimize(models);
   while (state.KeepRunning()) {
     for (auto& model : models) {
-      model.a();
-      model.b();
-      model.c();
+      model.f1();
+      model.f2();
+      model.f3();
     }
   }
 }
@@ -44,6 +44,7 @@ static constexpr int N = 10;
 
 // Always insert the same type in the type-erasure wrapper (may interact with
 // branch prediction and caches).
+BENCHMARK_TEMPLATE(BM_dispatch_many, inheritance_tag,         WithSize<4>, WithSize<4>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::remote_storage,    WithSize<4>, WithSize<4>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::sbo_storage<4>,    WithSize<4>, WithSize<4>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::sbo_storage<8>,    WithSize<4>, WithSize<4>)->Arg(N);
@@ -56,6 +57,7 @@ BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::local_storage<16>, WithSize<8>, WithS
 
 // Insert two different types in the type-erasure wrapper to look at what happens
 // with SBO.
+BENCHMARK_TEMPLATE(BM_dispatch_many, inheritance_tag,         WithSize<8>, WithSize<16>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::remote_storage,    WithSize<8>, WithSize<16>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::sbo_storage<4>,    WithSize<8>, WithSize<16>)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch_many, dyno::sbo_storage<8>,    WithSize<8>, WithSize<16>)->Arg(N);

Diff for: benchmark/storage/dispatch.single.cpp

@@ -21,15 +21,16 @@ static void BM_dispatch_single(benchmark::State& state) {
   model<StoragePolicy> m{T{}};
   benchmark::DoNotOptimize(m);
   while (state.KeepRunning()) {
-    m.a();
-    m.b();
-    m.c();
+    m.f1();
+    m.f2();
+    m.f3();
   }
 }
 
 template <std::size_t Bytes>
 using WithSize = std::aligned_storage_t<Bytes>;
 
+BENCHMARK_TEMPLATE(BM_dispatch_single, inheritance_tag,         WithSize<8>);
 BENCHMARK_TEMPLATE(BM_dispatch_single, dyno::remote_storage,    WithSize<8>);
 BENCHMARK_TEMPLATE(BM_dispatch_single, dyno::sbo_storage<4>,    WithSize<8>);
 BENCHMARK_TEMPLATE(BM_dispatch_single, dyno::sbo_storage<8>,    WithSize<8>);

Diff for: benchmark/storage/model.hpp

@@ -16,16 +16,16 @@ struct Concept : decltype(dyno::requires(
   dyno::Swappable{},
   dyno::Destructible{},
   dyno::Storable{},
-  "a"_s = dyno::function<void(dyno::T&)>,
-  "b"_s = dyno::function<void(dyno::T&)>,
-  "c"_s = dyno::function<void(dyno::T&)>
+  "f1"_s = dyno::function<void(dyno::T&)>,
+  "f2"_s = dyno::function<void(dyno::T&)>,
+  "f3"_s = dyno::function<void(dyno::T&)>
 )) { };
 
 template <typename T>
 auto const dyno::default_concept_map<Concept, T> = dyno::make_concept_map(
-  "a"_s = [](T& self) { benchmark::DoNotOptimize(self); },
-  "b"_s = [](T& self) { benchmark::DoNotOptimize(self); },
-  "c"_s = [](T& self) { benchmark::DoNotOptimize(self); }
+  "f1"_s = [](T& self) { benchmark::DoNotOptimize(self); },
+  "f2"_s = [](T& self) { benchmark::DoNotOptimize(self); },
+  "f3"_s = [](T& self) { benchmark::DoNotOptimize(self); }
 );
 
 template <typename StoragePolicy>
@@ -37,12 +37,47 @@ struct model {
 
   void swap(model& other) { poly_.swap(other.poly_); }
 
-  void a() { poly_.virtual_("a"_s)(poly_); }
-  void b() { poly_.virtual_("b"_s)(poly_); }
-  void c() { poly_.virtual_("c"_s)(poly_); }
+  void f1() { poly_.virtual_("f1"_s)(poly_); }
+  void f2() { poly_.virtual_("f2"_s)(poly_); }
+  void f3() { poly_.virtual_("f3"_s)(poly_); }
 
 private:
   dyno::poly<Concept, StoragePolicy> poly_;
 };
 
+struct inheritance_tag { };
+
+template <>
+struct model<inheritance_tag> {
+  template <typename T>
+  explicit model(T t)
+    : self_{std::make_unique<model_t<T>>(std::move(t))}
+  { }
+
+  void swap(model& other) { std::swap(self_, other.self_); }
+
+  void f1() { self_->f1(); }
+  void f2() { self_->f2(); }
+  void f3() { self_->f3(); }
+
+private:
+  struct concept_t {
+    virtual void f1() = 0;
+    virtual void f2() = 0;
+    virtual void f3() = 0;
+    virtual ~concept_t() { }
+  };
+
+  template <typename T>
+  struct model_t : concept_t {
+    model_t(T v) : value_{std::move(v)} { }
+    void f1() override { benchmark::DoNotOptimize(value_); }
+    void f2() override { benchmark::DoNotOptimize(value_); }
+    void f3() override { benchmark::DoNotOptimize(value_); }
+    T value_;
+  };
+
+  std::unique_ptr<concept_t> self_;
+};
+
 #endif // BENCHMARK_STORAGE_MODEL_HPP

Diff for: benchmark/storage/swap.different.cpp

@@ -28,6 +28,7 @@ static void BM_swap_different(benchmark::State& state) {
   }
 }
 
+BENCHMARK_TEMPLATE(BM_swap_different, inheritance_tag);
 BENCHMARK_TEMPLATE(BM_swap_different, dyno::sbo_storage<4>);
 BENCHMARK_TEMPLATE(BM_swap_different, dyno::sbo_storage<8>);
 BENCHMARK_TEMPLATE(BM_swap_different, dyno::sbo_storage<16>);

Diff for: benchmark/storage/swap.same.cpp

@@ -28,6 +28,7 @@ static void BM_swap_same(benchmark::State& state) {
   }
 }
 
+BENCHMARK_TEMPLATE(BM_swap_same, inheritance_tag);
 BENCHMARK_TEMPLATE(BM_swap_same, dyno::sbo_storage<4>);
 BENCHMARK_TEMPLATE(BM_swap_same, dyno::sbo_storage<8>);
 BENCHMARK_TEMPLATE(BM_swap_same, dyno::sbo_storage<16>);

Diff for: benchmark/vtable/dispatch.2.cpp

@@ -11,14 +11,10 @@ using namespace dyno::literals;
 
 
 // This benchmark measures the overhead of dispatching virtual calls using
-// different vtable policies.
+// different vtable policies, and inheritance.
 
-template <typename ...InlineMethods>
+template <typename VTablePolicy>
 static void BM_dispatch2(benchmark::State& state) {
-  using VTablePolicy = dyno::vtable<
-    dyno::local<dyno::only<InlineMethods...>>,
-    dyno::remote<dyno::everything_else>
-  >;
   unsigned int x = 0;
   model<VTablePolicy> m{x};
   int const N = state.range(0);
@@ -31,8 +27,15 @@ static void BM_dispatch2(benchmark::State& state) {
   }
 }
 
+template <typename ...InlineMethods>
+using inline_only = dyno::vtable<
+  dyno::local<dyno::only<InlineMethods...>>,
+  dyno::remote<dyno::everything_else>
+>;
+
 static constexpr int N = 100;
-BENCHMARK(BM_dispatch2)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch2, decltype("f1"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch2, decltype("f1"_s), decltype("f2"_s))->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inheritance_tag)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
 BENCHMARK_MAIN();

Diff for: benchmark/vtable/dispatch.3.cpp

@@ -11,14 +11,10 @@ using namespace dyno::literals;
 
 
 // This benchmark measures the overhead of dispatching virtual calls using
-// different vtable policies.
+// different vtable policies, and inheritance.
 
-template <typename ...InlineMethods>
+template <typename VTablePolicy>
 static void BM_dispatch3(benchmark::State& state) {
-  using VTablePolicy = dyno::vtable<
-    dyno::local<dyno::only<InlineMethods...>>,
-    dyno::remote<dyno::everything_else>
-  >;
   unsigned int x = 0;
   model<VTablePolicy> m{x};
   int const N = state.range(0);
@@ -32,9 +28,16 @@ static void BM_dispatch3(benchmark::State& state) {
   }
 }
 
+template <typename ...InlineMethods>
+using inline_only = dyno::vtable<
+  dyno::local<dyno::only<InlineMethods...>>,
+  dyno::remote<dyno::everything_else>
+>;
+
 static constexpr int N = 100;
-BENCHMARK(BM_dispatch3)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, decltype("f1"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, decltype("f1"_s), decltype("f2"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, decltype("f1"_s), decltype("f2"_s), decltype("f3"_s))->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inheritance_tag)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s)>)->Arg(N);
 BENCHMARK_MAIN();

Diff for: benchmark/vtable/dispatch.4.cpp

@@ -11,14 +11,10 @@ using namespace dyno::literals;
 
 
 // This benchmark measures the overhead of dispatching virtual calls using
-// different vtable policies.
+// different vtable policies, and inheritance.
 
-template <typename ...InlineMethods>
+template <typename VTablePolicy>
 static void BM_dispatch4(benchmark::State& state) {
-  using VTablePolicy = dyno::vtable<
-    dyno::local<dyno::only<InlineMethods...>>,
-    dyno::remote<dyno::everything_else>
-  >;
   unsigned int x = 0;
   model<VTablePolicy> m{x};
   int const N = state.range(0);
@@ -33,10 +29,17 @@ static void BM_dispatch4(benchmark::State& state) {
   }
 }
 
+template <typename ...InlineMethods>
+using inline_only = dyno::vtable<
+  dyno::local<dyno::only<InlineMethods...>>,
+  dyno::remote<dyno::everything_else>
+>;
+
 static constexpr int N = 100;
-BENCHMARK(BM_dispatch4)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, decltype("f1"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, decltype("f1"_s), decltype("f2"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, decltype("f1"_s), decltype("f2"_s), decltype("f3"_s))->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, decltype("f1"_s), decltype("f2"_s), decltype("f3"_s), decltype("f4"_s))->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inheritance_tag)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s), decltype("f4"_s)>)->Arg(N);
 BENCHMARK_MAIN();

Diff for: benchmark/vtable/model.hpp

@@ -7,6 +7,7 @@
 
 #include <dyno.hpp>
 #include <benchmark/benchmark.h>
+#include <memory>
 #include <utility>
 using namespace dyno::literals;
 
@@ -46,4 +47,40 @@ struct model {
   dyno::poly<Concept, dyno::local_storage<8>, VTablePolicy> poly_;
 };
 
+struct inheritance_tag { };
+
+template <>
+struct model<inheritance_tag> {
+  template <typename T>
+  explicit model(T t)
+    : self_{std::make_unique<model_t<T>>(std::move(t))}
+  { }
+
+  void f1() { self_->f1(); }
+  void f2() { self_->f2(); }
+  void f3() { self_->f3(); }
+  void f4() { self_->f4(); }
+
+private:
+  struct concept_t {
+    virtual void f1() = 0;
+    virtual void f2() = 0;
+    virtual void f3() = 0;
+    virtual void f4() = 0;
+    virtual ~concept_t() { }
+  };
+
+  template <typename T>
+  struct model_t : concept_t {
+    model_t(T v) : value_{std::move(v)} { }
+    void f1() override { ++value_; benchmark::DoNotOptimize(value_); }
+    void f2() override { ++value_; benchmark::DoNotOptimize(value_); }
+    void f3() override { ++value_; benchmark::DoNotOptimize(value_); }
+    void f4() override { ++value_; benchmark::DoNotOptimize(value_); }
+    T value_;
+  };
+
+  std::unique_ptr<concept_t> self_;
+};
+
 #endif // BENCHMARK_VTABLE_MODEL_HPP