/* Benchmark of boost::container::hub against plf::hive.
 * 
 * Copyright 2026 Joaquin M Lopez Munoz.
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 */

#include <boost/config.hpp>

#if BOOST_CXX_VERSION < 202002L

int main() { return 0; }

#else

#include <algorithm>
#include <array>
#include <chrono>
#include <numeric>
#include <iostream>
#include "../bench/bench_utils.hpp"

#ifndef ELEMENT_SIZE
#define ELEMENT_SIZE 64
//#define ELEMENT_SIZE 16
#endif
#define NONTRIVIAL_ELEMENT

std::chrono::high_resolution_clock::time_point measure_start, measure_pause;

template<typename F>
double measure(F f)
{
   using namespace std::chrono;

   //static const int              num_trials = 10;
   //static const milliseconds     min_time_per_trial(200);

   static const std::size_t      num_trials = 5;
   static const milliseconds     min_time_per_trial(100);

   std::array<double,num_trials> trials;

   for(std::size_t i = 0; i < num_trials; ++i) {
      int                               runs = 0;
      high_resolution_clock::time_point t2;
      decltype(f())                     res;

      measure_start = high_resolution_clock::now();
      do{
         clobber();
         res = f();
         escape(&res);
         t2 = high_resolution_clock::now();
         ++runs;
      }while((t2 - measure_start) < min_time_per_trial);
      trials[i] =
         duration_cast<duration<double>>(t2 - measure_start).count() / runs;
   }
   std::sort(trials.begin(), trials.end());

   return std::accumulate(trials.begin() + 2, trials.end() - 2, 0.0)/(trials.size() - 4);
}

BOOST_CONTAINER_FORCEINLINE void pause_timing()
{
   measure_pause = std::chrono::high_resolution_clock::now();
}

BOOST_CONTAINER_FORCEINLINE void resume_timing()
{
   measure_start += std::chrono::high_resolution_clock::now() - measure_pause;
}

#include <boost/container/experimental/hub.hpp>
#include <boost/container/experimental/nest.hpp>
#include <boost/core/detail/splitmix64.hpp>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include <string>
#include <sstream>
#include <vector>

//#define PLF_HIVE_BENCH
#if defined(PLF_HIVE_BENCH)
#include "plf_hive.h"
#endif

struct element
{
#if defined(NONTRIVIAL_ELEMENT)
   element(int n_) : n{ n_ }
   {
      std::memset(payload, 0, sizeof(payload));
   }

   ~element()
   {
      std::memset(payload, 0, sizeof(payload));
   }

   element(element&& x): n{x.n}
   {
      std::memcpy(payload, x.payload, sizeof(payload));
      std::memset(x.payload, 0, sizeof(payload));
   }

   element& operator=(element&& x)
   {
      n = x.n;
      std::memcpy(payload, x.payload, sizeof(payload));
      std::memset(x.payload, 0, sizeof(payload));
      return *this;
   }
#else
   element(int n_) : n{ n_ }
   {}
#endif

   operator int() const { return n; }

   int n;
   char payload[ELEMENT_SIZE - sizeof(int)];
};

struct urbg
{
   using result_type = boost::uint64_t;

   static constexpr result_type min() { return 0; }
   static constexpr result_type max() { return (result_type)(-1); }

   urbg() = default;
   explicit urbg(result_type seed): rng{seed} {}

   result_type operator()() { return rng(); }

   boost::detail::splitmix64 rng;
};

template<typename Container, typename Iterator>
BOOST_CONTAINER_FORCEINLINE void erase_void(Container& x, Iterator it)
{
   x.erase(it);
}

template<typename... Args, typename Iterator>
BOOST_CONTAINER_FORCEINLINE void erase_void(boost::container::hub<Args...>& x, Iterator it)
{
   x.erase_void(it);
}

template<typename... Args, typename Iterator>
BOOST_CONTAINER_FORCEINLINE void erase_void(boost::container::nest<Args...>& x, Iterator it)
{
   x.erase_void(it);
}

template<typename Container>
Container make(std::size_t n, double erasure_rate)
{
   std::uint64_t erasure_cut =
      (std::uint64_t)(erasure_rate * (double)(std::uint64_t)(-1));

   Container                                 c;
   urbg                                      rng;
   std::vector<typename Container::iterator> iterators;

   iterators.reserve(n);
   for(std::size_t i = 0; i < n; ++i) iterators.push_back(c.insert((int)rng()));
   std::shuffle(iterators.begin(), iterators.end(), rng);
   for(auto it: iterators) {
      if(rng() < erasure_cut) erase_void(c, it);
   }
   return c;
}

template<typename Container>
void fill(Container& c, std::size_t n)
{
   urbg rng;
   if(n > c.size()) {
      n -= c.size();
      while(n--) c.insert((int)rng());
   }
}
/*
static std::size_t min_size_exp = 3,
                   max_size_exp = 7;
static double      min_erasure_rate = 0.0,
                   max_erasure_rate = 0.9,
                   erase_rate_inc = 0.1;
*/

static std::size_t min_size_exp = 3,
                   max_size_exp = 5;
static double      min_erasure_rate = 0.1,
                   max_erasure_rate = 0.9,
                   erase_rate_inc = 0.4;

struct benchmark_result
{
   std::string                           title;
   std::vector<std::vector<std::string>> data;
   std::vector<std::vector<double>>      ratios;
};

template<typename FNum, typename FDen>
benchmark_result benchmark(const char* title, FNum fnum, FDen fden)
{
   static constexpr std::size_t size_limit =
      sizeof(std::size_t) == 4?
#if defined(BOOST_MSVC) && defined(_M_IX86)
                                600ull * 1024ull * 1024ull:
#else
                                800ull * 1024ull * 1024ull:
#endif
                                2048ull * 1024ull * 1024ull;

   benchmark_result res = {title, {}, {}};

   std::cout << std::string(41, '-') << "\n"
             << title << "\n"
             << "sizeof(element): " << sizeof(element) << "\n";
   std::cout << std::left << std::setw(11) << "" << "container size\n" << std::right
             << std::left << std::setw(11) << "erase rate" << std::right;
   for(std::size_t i = min_size_exp; i <= max_size_exp; ++i)
   {
      std::cout << "1.E" << i << " ";
   }
   std::cout << std::endl;

   for(double erasure_rate = min_erasure_rate;
              erasure_rate <= max_erasure_rate;
              erasure_rate += erase_rate_inc) {
      std::cout << std::left << std::setw(11) << erasure_rate << std::right << std::flush;

      res.data.push_back({});
      res.ratios.push_back({});

      for(std::size_t i = min_size_exp; i <= max_size_exp; ++i) {
         std::ostringstream out;
         std::size_t        n = (std::size_t)std::pow(10.0, (double)i);
         if(n * sizeof(element) > size_limit) {
            out << "----";
         }
         else{
            auto tnum = measure([&] { return fnum(n, erasure_rate); });
            auto tden  = measure([&] { return fden(n, erasure_rate); });
            double ratio = tnum / tden;
            out << std::fixed << std::setprecision(2) << ratio;
            res.ratios.back().push_back(ratio);
         }
         std::cout << out.str() << " " << std::flush;
         res.data.back().push_back(out.str());
      }
      std::cout << std::endl;
   }
   return res;
}

template<typename Container>
struct create
{
   unsigned int operator()(std::size_t n, double erasure_rate) const
   {
      unsigned int res = 0;
      {
         auto c = make<Container>(n, erasure_rate);
         fill(c, n);
         res = (unsigned int)c.size();
         pause_timing();
      }
      resume_timing();
      return res;
   }
};

template<typename Container>
struct create_and_destroy
{
   unsigned int operator()(std::size_t n, double erasure_rate) const
   {
      auto c = make<Container>(n, erasure_rate);
      fill(c, n);
      return (unsigned int)c.size();
   }
};

template<typename Container>
struct prepare
{
   const Container& get_container(std::size_t n_arg, double erasure_rate_arg)
   {
      if(n_arg != n_ || erasure_rate_arg != erasure_rate_) {
         pause_timing();
         n_ = n_arg;
         erasure_rate_ = erasure_rate_arg;
         c.clear();
         c.shrink_to_fit();
         c = make<Container>(n_, erasure_rate_);
         resume_timing();
      }
      return c;
   }

   std::size_t n_ = 0;
   double      erasure_rate_ = 0.0;
   Container   c;
};

template<typename Container>
struct for_each: prepare<Container>
{
   unsigned int operator()(std::size_t n, double erasure_rate)
   {
      unsigned int res = 0;
      auto& cr = this->get_container(n, erasure_rate);
      for(const auto& x: cr) res += (unsigned int)x;
      return res;
   }
};

template<typename Container>
struct visit_all: prepare<Container>
{
   unsigned int operator()(std::size_t n, double erasure_rate)
   {
      unsigned int res = 0;
      auto& cr = this->get_container(n, erasure_rate);
      cr.visit_all([&] (const auto& x) { res += (unsigned int)x; });
      return res;
   }
};

#if defined(PLF_HIVE_BENCH)

template<typename Element>
struct visit_all <plf::hive<Element>>
   : for_each< plf::hive<Element> >
{};

#endif

template<typename Container>
struct sort
{
   unsigned int operator()(std::size_t n, double erasure_rate) const
   {
      pause_timing();
      auto c = make<Container>(n, erasure_rate);
      resume_timing();
      c.sort();
      return (unsigned int)c.size();
   }
};

using table = std::vector<benchmark_result>;

double geomean(const table& t)
{
   double log_sum = 0.0;
   std::size_t count = 0;
   for(const auto& bench: t) {
      for(const auto& row: bench.ratios) {
         for(double r: row) {
            if(r > 0.0) { log_sum += std::log(r); ++count; }
         }
      }
   }
   return count > 0 ? std::exp(log_sum / (double)count) : 0.0;
}

double geomean(const benchmark_result& bench)
{
   double log_sum = 0.0;
   std::size_t count = 0;
   for(const auto& row: bench.ratios) {
      for(double r: row) {
         if(r > 0.0) { log_sum += std::log(r); ++count; }
      }
   }
   return count > 0 ? std::exp(log_sum / (double)count) : 0.0;
}

void write_table(const table& t, const char* filename)
{
   static std::size_t first_column_width = 11;
   static std::size_t data_column_width = (max_size_exp + 1 - min_size_exp) * 5;
   std::size_t        num_data_columns = t.size();
   std::size_t        table_width = first_column_width + 2 + num_data_columns * (data_column_width + 2) + 1;

   std::ofstream fout(filename);
   std::ostream &out = fout;
   //(void)filename;
   //std::ostream &out = std::cout;

   auto data_horizontal_line =
      std::string(first_column_width + 2, ' ') + std::string(table_width - first_column_width - 2, '-');
   auto table_horizontal_line = std::string(table_width, '-');

   out << std::left;

   out << data_horizontal_line << "\n";

   out << "  " << std::setw(static_cast<int>(first_column_width)) << " ";
   out << std::setw(static_cast<int>(table_width - first_column_width - 3))
       << std::string("| sizeof(element): ") + std::to_string(ELEMENT_SIZE) << "|\n";

   out << data_horizontal_line << "\n";

   out << "  " << std::setw(static_cast<int>(first_column_width)) << " ";
   for(const benchmark_result& res: t) {
      out << "| " << std::setw(static_cast<int>(data_column_width)) << res.title;
   }
   out << "|\n";

   out << data_horizontal_line << "\n";

   out << "  " << std::setw(static_cast<int>(first_column_width)) << " " ;
   for(std::size_t i = 0; i < num_data_columns; ++i) {
      out << "| " << std::setw(static_cast<int>(data_column_width)) << "container size";
   }
   out << "|\n";

   out << table_horizontal_line << "\n";

   out << "| " << std::setw(static_cast<int>(first_column_width)) << "erase rate";
   for(std::size_t i = 0; i < num_data_columns; ++i) {
      out << "| ";
      for(auto j = min_size_exp; j <= max_size_exp; ++j) {
         out << "1.E" << j << " ";
      }
   }
   out << "|\n";

   out << table_horizontal_line << "\n";

   std::size_t row = 0;
   for(double erasure_rate = min_erasure_rate;
       erasure_rate <= max_erasure_rate;
       erasure_rate += erase_rate_inc, ++row) {
      out << "| " << std::setw(static_cast<int>(first_column_width)) << erasure_rate;
      for(const benchmark_result& res: t) {
         out << "| ";
         for(const auto& x: res.data[row]) {
            out << x << " ";
         }
      }
      out << "|\n";
   }

   out << table_horizontal_line;
}

int main(int argc,char* argv[])
{
   (void)argc;
   (void)argv;

   using namespace boost::container;
   BOOST_CONTAINER_TRY{
      #ifdef PLF_HIVE_BENCH
      using num = plf::hive<element>;
      #else
      using num = hub<element>;
      //using num = nest<element, void, nest_options_t< store_data_in_block<true> > >;
      //using num = nest<element, void, nest_options_t< prefetch<false> > >;
      //using num = nest<element, void, nest_options_t< prefetch<false>, store_data_in_block<true> > >;
      #endif
      using den  = nest<element>;

      table t;

      t.push_back(benchmark(
         "creat, ins, erase, ins",
         create<num>{}, create<den>{}));
      t.push_back(benchmark(
         "creat, ins, erase, ins, destroy",
         create_and_destroy<num>{}, create_and_destroy<den>{}));
      t.push_back(benchmark(
         "for_each",
         for_each<num>{}, for_each<den>{}));
      t.push_back(benchmark(
         "visit_all",
         visit_all<num>{}, visit_all<den>{}));
      t.push_back(benchmark(
         "sort",
         sort<num>{}, sort<den>{}));

      const char* filename = "hub_test.txt";
      write_table(t, filename);

      std::cout << "\n" << std::string(41, '-') << "\n"
                << "Geometric means (num/den time ratio)\n";
      for(const auto& bench: t) {
         std::cout << std::left << std::setw(30) << bench.title
                   << std::fixed << std::setprecision(3) << geomean(bench) << "\n";
      }
      std::cout << std::left << std::setw(30) << "OVERALL"
                << std::fixed << std::setprecision(3) << geomean(t) << "\n";
   }
   BOOST_CONTAINER_CATCH(const std::exception& e) {
      #ifndef BOOST_NO_EXCEPTIONS
      std::cerr << e.what() << std::endl;
      #endif
   }
   BOOST_CONTAINER_CATCH_END
}

#endif