statistics.h

#ifndef ADIAR_STATISTICS_H
#define ADIAR_STATISTICS_H
 
 
#include <cstddef>
#include <iostream>
 
#include <adiar/internal/cnl.h>
 
namespace adiar
{
 
  struct statistics
  {
    // I/O
 
    struct arc_file_t
    {
      uintwide push_internal = 0;
 
      uintwide push_in_order = 0;
 
      uintwide push_out_of_order = 0;
 
      uintwide push_level = 0;
 
      uintwide sort_out_of_order = 0;
    }
    arc_file;
 
    struct node_file_t
    {
      uintwide push_node = 0;
 
      uintwide push_level = 0;
    }
    node_file;
 
    // Data Structures
 
    struct levelized_priority_queue_t
    {
      uintwide push_bucket = 0;
 
      uintwide push_overflow = 0;
 
      uintwide sum_predicted_max_size = 0;
 
      uintwide sum_actual_max_size = 0;
 
      double sum_max_size_ratio = 0.0;
 
      size_t sum_destructors = 0;
    }
    levelized_priority_queue;
 
    // Algorithms
 
    struct __alg_base
    {
      struct __lpq_t : public levelized_priority_queue_t
      {
        uintwide unbucketed = 0;
 
        uintwide internal = 0;
 
        uintwide external = 0;
 
        uintwide
        total() const
        {
          return unbucketed + internal + external;
        }
      }
      lpq;
    };
 
    struct __random_access_base
    {
      uintwide runs = 0;
 
      uintwide used_narrowest = 0;
 
      uintwide acc_width = 0;
 
      size_t min_width = std::numeric_limits<size_t>::max();
 
      size_t max_width = 0u;
    };
 
    struct __pq2_base
    {
      uintwide runs = 0;
 
      uintwide pq_2_elems = 0;
    };
 
    // Algorithms: Top-down Sweeps
 
    struct count_t : public __alg_base
    {
    }
    count;
 
    struct equality_t : public __alg_base
    {
      // Early termination cases
 
      uintwide exit_on_same_file = 0;
 
      uintwide exit_on_nodecount = 0;
 
      uintwide exit_on_varcount = 0;
 
      uintwide exit_on_width = 0;
 
      uintwide exit_on_terminalcount = 0;
 
      uintwide exit_on_levels_mismatch = 0;
 
      struct slow_t
      {
        uintwide runs = 0;
 
        uintwide exit_on_root = 0;
 
        uintwide exit_on_processed_on_level = 0;
 
        uintwide exit_on_children = 0;
      }
      slow_check;
 
      struct fast_t
      {
        uintwide runs = 0;
 
        uintwide exit_on_mismatch = 0;
      }
      fast_check;
    }
    equality;
 
    struct intercut_t : public __alg_base
    {
    }
    intercut;
 
    struct optmin_t : public __alg_base
    {
    }
    optmin;
 
    struct prod2_t : public __alg_base
    {
      uintwide trivial_file = 0;
 
      uintwide trivial_terminal = 0;
 
      __random_access_base ra;
 
      __pq2_base pq;
    }
    prod2;
 
    struct prod3_t : public __alg_base
    {
    }
    prod3;
 
    struct quantify_t : public __alg_base
    {
      uintwide runs = 0;
 
      uintwide skipped = 0;
 
      uintwide singleton_sweeps = 0;
 
      uintwide nested_sweeps = 0;
 
      struct nested_transposition_t
      {
        uintwide none = 0;
 
        uintwide simple = 0;
 
        uintwide singleton = 0;
 
        uintwide pruning = 0;
 
        uintwide partial = 0;
 
        uintwide partial_terminations = 0;
 
        uintwide partial_repetitions = 0;
      } nested_transposition;
 
      struct nested_policy_t
      {
        uintwide shortcut_terminal = 0;
 
        uintwide shortcut_node = 0;
 
        uintwide products = 0;
      } nested_policy;
 
      __random_access_base ra;
 
      __pq2_base pq;
 
      uintwide requests[2] = { 0, 0 };
 
      uintwide requests_unique[2] = { 0, 0 };
    }
    quantify;
 
    struct select_t : public __alg_base
    {
    }
    select;
 
    // Algorithms: Bottom-up Sweeps
 
    struct reduce_t : public __alg_base
    {
      uintwide sum_node_arcs = 0;
 
      uintwide sum_terminal_arcs = 0;
 
      uintwide removed_by_rule_1 = 0;
 
      uintwide removed_by_rule_2 = 0;
    }
    reduce;
 
    // Algorithms: Other
 
    struct replace_t
    {
      uintwide terminal_returns = 0;
 
      uintwide identity_returns = 0;
 
      uintwide identity_reduces = 0;
 
      uintwide shift_returns = 0;
 
      uintwide monotonic_scans = 0;
 
      uintwide monotonic_reduces = 0;
 
      uintwide nested_sweeps = 0;
    }
    replace;
 
    struct nested_sweeping_t
    {
      uintwide skips = 0;
 
      uintwide runs = 0;
 
      struct outer_up_t : public reduce_t
      {
        uintwide reduced_levels = 0;
 
        uintwide reduced_levels__fast = 0;
 
        uintwide nested_levels = 0;
 
        uintwide skipped_nested_levels = 0;
 
        uintwide skipped_nested_levels__prune = 0;
 
        uintwide collapse_to_terminal = 0;
      }
      outer_up;
 
      struct inner_down_t
      {
        struct inputs_t
        {
          uintwide acc_size = 0;
 
          uintwide max_size = 0;
 
          uintwide acc_width = 0;
 
          uintwide max_width = 0;
 
          uintwide acc_levels = 0;
 
          uintwide max_levels = 0;
        } inputs;
 
        struct requests_t
        {
          uintwide terminals = 0;
 
          uintwide preserving = 0;
 
          uintwide modifying = 0;
        } requests;
 
        uintwide removed_by_rule_1 = 0;
 
        uintwide ra_runs = 0;
 
        uintwide pq_runs = 0;
      }
      inner_down;
 
      struct inner_up_t : public reduce_t
      {
        uintwide inner_arcs = 0;
 
        uintwide outer_arcs = 0;
 
        uintwide reduced_levels = 0;
 
        uintwide reduced_levels__fast = 0;
      }
      inner_up;
    }
    nested_sweeping;
  };
 
  statistics
  statistics_get();
 
  void
  statistics_print(std::ostream& o = std::cout);
 
  void
  statistics_reset();
 
}
 
#endif // ADIAR_STATISTICS_H