anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState Struct Reference

Collaboration diagram for anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState:

Public Types
enum	TuningDirection { TuningDirection::SMALLER, TuningDirection::LARGER }

Public Member Functions
	TuningState (const size_t overlaps_max_table_size_bytes, const double overlaps_target_entries_per_bin)
bool	operator() (const HashTableProps &new_props, const bool new_overlaps_threshold)
bool	hashTableTooBig () const
bool	keysPerBinIncreasing () const
bool	previousIterationValid () const
bool	keysPerBinUnderThreshold () const

Public Attributes
HashTableProps	crt_props
HashTableProps	prev_props
double	chosen_overlaps_threshold
size_t	crt_step
size_t	crt_reverse_search_iteration
size_t	overlaps_max_table_size_bytes
double	overlaps_target_entries_per_bin
const size_t	max_reverse_search_iterations {8}

Detailed Description

Definition at line 232 of file OverlapsJoinHashTable.cpp.

Member Enumeration Documentation

enum anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::TuningDirection

strong

Enumerator
SMALLER
LARGER

Definition at line 249 of file OverlapsJoinHashTable.cpp.

{ SMALLER, LARGER };

Constructor & Destructor Documentation

anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::TuningState ( const size_t  overlaps_max_table_size_bytes, const double  overlaps_target_entries_per_bin  )

inline

Definition at line 233 of file OverlapsJoinHashTable.cpp.

      : crt_props(HashTableProps::invalid())
      , prev_props(HashTableProps::invalid())
      , chosen_overlaps_threshold(-1)
      , crt_step(0)
      , crt_reverse_search_iteration(0)
      , overlaps_max_table_size_bytes(overlaps_max_table_size_bytes)
      , overlaps_target_entries_per_bin(overlaps_target_entries_per_bin) {}

Member Function Documentation

bool anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::hashTableTooBig ( ) const

inline

Definition at line 341 of file OverlapsJoinHashTable.cpp.

                               {
    return crt_props.hash_table_size > overlaps_max_table_size_bytes;
  }

bool anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::keysPerBinIncreasing ( ) const

inline

Definition at line 345 of file OverlapsJoinHashTable.cpp.

                                    {
    return crt_props.keys_per_bin > prev_props.keys_per_bin;
  }

bool anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::keysPerBinUnderThreshold ( ) const

inline

Definition at line 353 of file OverlapsJoinHashTable.cpp.

                                        {
    return crt_props.keys_per_bin < overlaps_target_entries_per_bin;
  }

bool anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::operator() ( const HashTableProps &  new_props, const bool  new_overlaps_threshold  )

inline

Returns true to continue tuning, false to end the loop with the above overlaps threshold

Definition at line 263 of file OverlapsJoinHashTable.cpp.

References CHECK, UNREACHABLE, and VLOG.

                                                                                      {
    prev_props = crt_props;
    crt_props = new_props;
    crt_step++;

    if (hashTableTooBig() || keysPerBinIncreasing()) {
      if (hashTableTooBig()) {
        VLOG(1) << "Reached hash table size limit: " << overlaps_max_table_size_bytes
                << " with " << crt_props.hash_table_size << " byte hash table, "
                << crt_props.keys_per_bin << " keys per bin.";
      } else if (keysPerBinIncreasing()) {
        VLOG(1) << "Keys per bin increasing from " << prev_props.keys_per_bin << " to "
                << crt_props.keys_per_bin;
        CHECK(previousIterationValid());
      }
      if (previousIterationValid()) {
        VLOG(1) << "Using previous threshold value " << chosen_overlaps_threshold;
        crt_props = prev_props;
        return false;
      } else {
        CHECK(hashTableTooBig());
        crt_reverse_search_iteration++;
        chosen_overlaps_threshold = new_overlaps_threshold;

        if (crt_reverse_search_iteration == max_reverse_search_iterations) {
          VLOG(1) << "Hit maximum number (" << max_reverse_search_iterations
                  << ") of reverse tuning iterations. Aborting tuning";
          // use the crt props, but don't bother trying to tune any farther
          return false;
        }

        if (crt_reverse_search_iteration > 1 &&
            crt_props.hash_table_size == prev_props.hash_table_size) {
          // hash table size is not changing, bail
          VLOG(1) << "Hash table size not decreasing (" << crt_props.hash_table_size
                  << " bytes) and still above maximum allowed size ("
                  << overlaps_max_table_size_bytes << " bytes). Aborting tuning";
          return false;
        }

        // if the hash table is too big on the very first step, change direction towards
        // larger bins to see if a slightly smaller hash table will fit
        if (crt_step == 1 && crt_reverse_search_iteration == 1) {
          VLOG(1)
              << "First iteration of overlaps tuning led to hash table size over "
                 "limit. Reversing search to try larger bin sizes (previous threshold: "
              << chosen_overlaps_threshold << ")";
          // Need to change direction of tuning to tune "up" towards larger bins
          tuning_direction = TuningDirection::LARGER;
        }
        return true;
      }
      UNREACHABLE();
    }

    chosen_overlaps_threshold = new_overlaps_threshold;

    if (keysPerBinUnderThreshold()) {
      VLOG(1) << "Hash table reached size " << crt_props.hash_table_size
              << " with keys per bin " << crt_props.keys_per_bin << " under threshold "
              << overlaps_target_entries_per_bin << ". Terminating bucket size loop.";
      return false;
    }

    if (crt_reverse_search_iteration > 0) {
      // We always take the first tuning iteration that succeeds when reversing
      // direction, as if we're here we haven't had a successful iteration and we're
      // "backtracking" our search by making bin sizes larger
      VLOG(1) << "On reverse (larger tuning direction) search found workable "
              << " hash table size of " << crt_props.hash_table_size
              << " with keys per bin " << crt_props.keys_per_bin
              << ". Terminating bucket size loop.";
      return false;
    }

    return true;
  }

bool anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::previousIterationValid ( ) const

inline

Definition at line 349 of file OverlapsJoinHashTable.cpp.

                                      {
    return tuning_direction == TuningDirection::SMALLER && crt_step > 1;
  }

Member Data Documentation

double anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::chosen_overlaps_threshold

Definition at line 248 of file OverlapsJoinHashTable.cpp.

HashTableProps anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::crt_props

Definition at line 244 of file OverlapsJoinHashTable.cpp.

size_t anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::crt_reverse_search_iteration

Definition at line 254 of file OverlapsJoinHashTable.cpp.

size_t anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::crt_step

Definition at line 253 of file OverlapsJoinHashTable.cpp.

const size_t anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::max_reverse_search_iterations {8}

Definition at line 257 of file OverlapsJoinHashTable.cpp.

size_t anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::overlaps_max_table_size_bytes

Definition at line 255 of file OverlapsJoinHashTable.cpp.

double anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::overlaps_target_entries_per_bin

Definition at line 256 of file OverlapsJoinHashTable.cpp.

HashTableProps anonymous_namespace{OverlapsJoinHashTable.cpp}::TuningState::prev_props

Definition at line 245 of file OverlapsJoinHashTable.cpp.

---

The documentation for this struct was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/JoinHashTable/OverlapsJoinHashTable.cpp