Compare sdd::mem::variant and eggs::variant (https://github.com/eggs-cpp/variant)

variant_eggs.cc

#include <chrono>
#include <iostream>
#include <type_traits>
#include <eggs/variant.hpp>

/* -------------------------------------------------------------------------------- */

class timer
{
private:

  std::chrono::time_point<std::chrono::system_clock> start_;

public:

  timer()
    : start_(std::chrono::system_clock::now())
  {}

  void
  reset()
  {
    start_ = std::chrono::system_clock::now();
  }

  std::chrono::duration<double>
  duration()
  {
    return std::chrono::system_clock::now() - start_;
  }
};

/* -------------------------------------------------------------------------------- */

struct foo{};
struct bar{};

std::ostream& operator<<(std::ostream& os, const foo&){return os << "foo";}
std::ostream& operator<<(std::ostream& os, const bar&){return os << "bar";}

/* -------------------------------------------------------------------------------- */

struct visitor
{
  template <typename T>
  int operator()(const T&) const {return 1;}

  int operator()(const foo&) const {return 2;}
};

struct binary_visitor
{
  template <typename T, typename U>
  int operator()(const T&, const U&) const noexcept {return 0;}

  int operator()(unsigned int, const bar&) const noexcept {return 1;}
};

// struct binary_visitor2
// {
//   int operator()(const foo&, const foo&) const noexcept {return 0;}
//   int operator()(const foo&, const bar&) const noexcept {return 1;}
//   int operator()(const bar&, const foo&) const noexcept {return 2;}
//   int operator()(const bar&, const bar&) const noexcept {return 3;}
// };
//
// struct binary_visitor3
// {
//   int operator()(const foo&, int) const noexcept {return 0;}
//   int operator()(const foo&, char) const noexcept {return 1;}
//   int operator()(const bar&, int) const noexcept {return 2;}
//   int operator()(const bar&, char) const noexcept {return 3;}
// };


/* -------------------------------------------------------------------------------- */

int main()
{
  // using variant_ty = eggs::variant<unsigned int, double, foo, bar, char>;
  // // std::cout << variant_ty::size << '\n';
  // variant_ty v0 = 0u;
  // variant_ty v1 = foo{};
  // variant_ty v2 = bar{};
  // std::cout << visit(gen_visitor{}, v0);

  // timer t;
  //
  // constexpr auto loops = 999999999u;
  // auto dummy = 0ul;
  // visitor vis;
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += eggs::variants::apply<int>(vis, v0);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += eggs::variants::apply<int>(vis, v1);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += eggs::variants::apply<int>(vis, v2);
  // }
  // std::cout << dummy << '\n';
  // std::cout << t.duration().count() << '\n';

  using variant1_ty = eggs::variant<unsigned int, double, foo, bar, char>;
  variant1_ty v0 = bar{};
  variant1_ty v1 = 0u;
  variant1_ty v2 = foo{};

  timer t;

  constexpr auto loops = 999999999u;
  auto dummy = 0ul;
  binary_visitor vis;
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += eggs::variants::apply<int>(vis, v0, v1);
  }
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += eggs::variants::apply<int>(vis, v1, v2);
  }
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += eggs::variants::apply<int>(vis, v2, v1);
  }
  std::cout << dummy << '\n';
  std::cout << t.duration().count() << '\n';

  return 0;
}

variant_sdd.cc

#include <chrono>
#include <iostream>
#include <type_traits>

#include <sdd/mem/variant.hh>

/* -------------------------------------------------------------------------------- */

class timer
{
private:

  std::chrono::time_point<std::chrono::system_clock> start_;

public:

  timer()
    : start_(std::chrono::system_clock::now())
  {}

  void
  reset()
  {
    start_ = std::chrono::system_clock::now();
  }

  std::chrono::duration<double>
  duration()
  {
    return std::chrono::system_clock::now() - start_;
  }
};

/* -------------------------------------------------------------------------------- */

struct foo{};
struct bar{};

/* -------------------------------------------------------------------------------- */

struct visitor
{
  template <typename T>
  int operator()(const T&) const {return 1;}

  int operator()(const foo&) const {return 2;}
};

struct binary_visitor
{
  template <typename T, typename U>
  int operator()(const T&, const U&) const noexcept {return 0;}

  int operator()(unsigned int, const bar&) const noexcept {return 1;}
};

/* -------------------------------------------------------------------------------- */

int main()
{
  using namespace sdd::mem;
  
  // using variant_ty = variant<unsigned int, double, foo, bar, char>;
  // variant_ty v0{construct<unsigned int>()};
  // variant_ty v1{construct<foo>()};
  // variant_ty v2{construct<bar>()};
  //
  // timer t;
  //
  // constexpr auto loops = 999999999u;
  // auto dummy = 0ul;
  // visitor vis;
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += apply_visitor(vis, v0);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += apply_visitor(vis, v1);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += apply_visitor(vis, v2);
  // }
  // std::cout << dummy << '\n';
  // std::cout << t.duration().count() << '\n';

  // using variant1_ty = variant<unsigned int, double, foo, bar, char>;
  // using variant2_ty = variant<double, foo, bar, char, int>;
  // // std::cout << variant_ty::size << '\n';
  // variant1_ty v1_0{construct<unsigned int>()};
  // variant1_ty v1_1{construct<foo>()};
  // variant1_ty v1_2{construct<bar>()};
  //
  // variant2_ty v2_0{construct<bar>()};
  // variant2_ty v2_1{construct<int>()};
  //
  // timer t;
  //
  // constexpr auto loops = 999999999u;
  // auto dummy = 0ul;
  // binary_visitor vis;
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += binary_visit(vis, v1_0, v2_0);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += binary_visit(vis, v1_1, v2_1);
  // }
  // for (auto i = 0u; i < loops; ++i)
  // {
  //   dummy += binary_visit(vis, v2_1, v1_2);
  // }
  // std::cout << dummy << '\n';
  // std::cout << t.duration().count() << '\n';

  using variant1_ty = variant<unsigned int, double, foo, bar, char>;
  variant1_ty v0{construct<bar>()};
  variant1_ty v1{construct<unsigned int>()};
  variant1_ty v2{construct<foo>()};

  timer t;

  constexpr auto loops = 999999999u;
  auto dummy = 0ul;
  binary_visitor vis;
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += apply_visitor(vis, v0, v1);
  }
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += apply_visitor(vis, v1, v2);
  }
  for (auto i = 0u; i < loops; ++i)
  {
    dummy += apply_visitor(vis, v2, v1);
  }
  std::cout << dummy << '\n';
  std::cout << t.duration().count() << '\n';

  return 0;
}