lolly_tree_bench.cpp File Reference

#include "lolly/data/lolly_tree.hpp"
#include <nanobench.h>

Include dependency graph for lolly_tree_bench.cpp:

Go to the source code of this file.

Namespaces
namespace	lolly

Typedefs
using	test_tree = lolly::data::lolly_tree<int>

Functions
void	lolly::init_tbox ()
static test_tree	generate_test_tree (int i=0, int d=3)
int	main ()

Variables
static ankerl::nanobench::Bench	bench

Detailed Description

Copyright

GPLv3

Benchmark for tree

Author

jingkaimori

Date

2024

Definition in file lolly_tree_bench.cpp.

Typedef Documentation

test_tree

using test_tree = lolly::data::lolly_tree<int>

Definition at line 17 of file lolly_tree_bench.cpp.

Function Documentation

generate_test_tree()

static test_tree generate_test_tree ( int i = 0, int d = 3 )

static

Definition at line 20 of file lolly_tree_bench.cpp.

                                        {
  if (d == 0) return test_tree (as_string (i));
  else {
    int       n= 6 + ((int) (2 * sin (1.0 * i * d)));
    test_tree t (2, n);
    for (int j= 0; j < n; i++, j++)
      t[j]= test_tree (i, d - 1);
    return t;
  }
}

main()

int main

(

)

Definition at line 32 of file lolly_tree_bench.cpp.

        {
  lolly::init_tbox ();
#ifdef OS_WASM
  bench.minEpochIterations (2000);
#else
  bench.minEpochIterations (200000);
#endif
  bench.complexityN (1).run ("construct atomic tree",
                             [&] { test_tree ("abc"); });
  bench.run ("construct compound tree of depth from argument",
             [&] { test_tree (10, "abc", "def", "ghi"); });
  bench.run ("construct compound tree from array",
             [&] { test_tree (10, array<test_tree> ("abc", "def", "ghi")); });
  for (int d= 1; d < 6; d++) {
    bench.complexityN (d);
    bench.run ("construct compound tree of given depth",
               [&] { generate_test_tree (0, d); });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr= generate_test_tree (0, d);
    bench.complexityN (d).run ("type of tree",
                               [&] { lolly::data::is_compound (tr); });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr= generate_test_tree (0, d);
    bench.complexityN (d).run ("size of tree", [&] { lolly::data::N (tr); });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr= generate_test_tree (0, d);
    bench.complexityN (d).run ("immutable index of tree",
                               [&] { lolly::data::A (tr)[0]; });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr= generate_test_tree (0, d);
    bench.complexityN (d).run ("mutable index of tree",
                               [&] { lolly::data::AR (tr)[0]= "abcdef"; });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr= generate_test_tree (0, d);
    bench.complexityN (d).run ("copy tree", [&] { lolly::data::copy (tr); });
  }
  for (int d= 1; d < 6; d++) {
    static test_tree tr1= generate_test_tree (0, d),
                     tr2= generate_test_tree (0, d);
    bench.complexityN (d).run ("equality of tree", [&] { tr1 == tr2; });
  }
}

Variable Documentation

bench

ankerl::nanobench::Bench bench

static

Definition at line 11 of file lolly_tree_bench.cpp.