PerfectJoinHashTable.h File Reference

#include "Analyzer/Analyzer.h"
#include "DataMgr/Allocators/ThrustAllocator.h"
#include "DataMgr/Chunk/Chunk.h"
#include "QueryEngine/ColumnarResults.h"
#include "QueryEngine/DataRecycler/HashingSchemeRecycler.h"
#include "QueryEngine/DataRecycler/HashtableRecycler.h"
#include "QueryEngine/Descriptors/InputDescriptors.h"
#include "QueryEngine/Descriptors/RowSetMemoryOwner.h"
#include "QueryEngine/ExpressionRange.h"
#include "QueryEngine/InputMetadata.h"
#include "QueryEngine/JoinHashTable/HashJoin.h"
#include "QueryEngine/JoinHashTable/PerfectHashTable.h"
#include <llvm/IR/Value.h>
#include <functional>
#include <memory>
#include <mutex>
#include <stdexcept>

Include dependency graph for PerfectJoinHashTable.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	PerfectJoinHashTable
struct	PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin

Functions
bool	needs_dictionary_translation (const InnerOuter &inner_outer_col_pair, const InnerOuterStringOpInfos &inner_outer_string_op_infos, const Executor *executor)
Data_Namespace::MemoryLevel	get_effective_memory_level (const Data_Namespace::MemoryLevel memory_level, const bool needs_dict_translation)
std::vector < Fragmenter_Namespace::FragmentInfo >	only_shards_for_device (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments, const int device_id, const int device_count)
const InputTableInfo &	get_inner_query_info (const int inner_table_id, const std::vector< InputTableInfo > &query_infos)
size_t	get_entries_per_device (const size_t total_entries, const size_t shard_count, const size_t device_count, const Data_Namespace::MemoryLevel memory_level)

Function Documentation

Data_Namespace::MemoryLevel get_effective_memory_level ( const Data_Namespace::MemoryLevel  memory_level, const bool  needs_dict_translation  )

inline

Definition at line 296 of file PerfectJoinHashTable.h.

References Data_Namespace::CPU_LEVEL.

Referenced by PerfectJoinHashTable::fetchColumnsForDevice(), BaselineJoinHashTable::fetchColumnsForDevice(), PerfectJoinHashTable::reifyForDevice(), and BaselineJoinHashTable::reifyForDevice().

                                       {
  if (needs_dict_translation) {
    return Data_Namespace::CPU_LEVEL;
  }
  return memory_level;
}

Here is the caller graph for this function:

size_t get_entries_per_device	(	const size_t	total_entries,
		const size_t	shard_count,
		const size_t	device_count,
		const Data_Namespace::MemoryLevel	memory_level
	)

Definition at line 1260 of file PerfectJoinHashTable.cpp.

References CHECK_GT, and Data_Namespace::GPU_LEVEL.

Referenced by OverlapsJoinHashTable::computeHashTableCounts(), RangeJoinHashTable::computeRangeHashTableCounts(), and BaselineJoinHashTable::reifyWithLayout().

                                                                            {
  const auto entries_per_shard =
      shard_count ? (total_entries + shard_count - 1) / shard_count : total_entries;
  size_t entries_per_device = entries_per_shard;
  if (memory_level == Data_Namespace::GPU_LEVEL && shard_count) {
    const auto shards_per_device = (shard_count + device_count - 1) / device_count;
    CHECK_GT(shards_per_device, 0u);
    entries_per_device = entries_per_shard * shards_per_device;
  }
  return entries_per_device;
}

Here is the caller graph for this function:

const InputTableInfo& get_inner_query_info	(	const int	inner_table_id,
		const std::vector< InputTableInfo > &	query_infos
	)

Definition at line 1246 of file PerfectJoinHashTable.cpp.

References CHECK.

Referenced by PerfectJoinHashTable::getInnerQueryInfo(), RangeJoinHashTable::getInstance(), OverlapsJoinHashTable::getInstance(), RangeJoinHashTable::reifyWithLayout(), OverlapsJoinHashTable::reifyWithLayout(), and BaselineJoinHashTable::reifyWithLayout().

                                                  {
  std::optional<size_t> ti_idx;
  for (size_t i = 0; i < query_infos.size(); ++i) {
    if (inner_table_id == query_infos[i].table_id) {
      ti_idx = i;
      break;
    }
  }
  CHECK(ti_idx);
  return query_infos[*ti_idx];
}

Here is the caller graph for this function:

bool needs_dictionary_translation	(	const InnerOuter &	inner_outer_col_pair,
		const InnerOuterStringOpInfos &	inner_outer_string_op_infos,
		const Executor *	executor
	)

Definition at line 267 of file PerfectJoinHashTable.cpp.

References CHECK, CHECK_EQ, get_column_descriptor_maybe(), and get_column_type().

                              {
  if (inner_outer_string_op_infos.first.size() ||
      inner_outer_string_op_infos.second.size()) {
    return true;
  }
  auto inner_col = inner_outer_col_pair.first;
  auto outer_col_expr = inner_outer_col_pair.second;
  const auto catalog = executor->getCatalog();
  CHECK(catalog);
  const auto inner_cd = get_column_descriptor_maybe(
      inner_col->get_column_id(), inner_col->get_table_id(), *catalog);
  const auto& inner_ti = get_column_type(inner_col->get_column_id(),
                                         inner_col->get_table_id(),
                                         inner_cd,
                                         executor->getTemporaryTables());
  // Only strings may need dictionary translation.
  if (!inner_ti.is_string()) {
    return false;
  }
  const auto outer_col = dynamic_cast<const Analyzer::ColumnVar*>(outer_col_expr);
  CHECK(outer_col);
  const auto outer_cd = get_column_descriptor_maybe(
      outer_col->get_column_id(), outer_col->get_table_id(), *catalog);
  // Don't want to deal with temporary tables for now, require translation.
  if (!inner_cd || !outer_cd) {
    return true;
  }
  const auto& outer_ti = get_column_type(outer_col->get_column_id(),
                                         outer_col->get_table_id(),
                                         outer_cd,
                                         executor->getTemporaryTables());
  CHECK_EQ(inner_ti.is_string(), outer_ti.is_string());
  // If the two columns don't share the dictionary, translation is needed.
  if (outer_ti.get_comp_param() != inner_ti.get_comp_param()) {
    return true;
  }
  const auto inner_str_dict_proxy =
      executor->getStringDictionaryProxy(inner_col->get_comp_param(), true);
  CHECK(inner_str_dict_proxy);
  const auto outer_str_dict_proxy =
      executor->getStringDictionaryProxy(inner_col->get_comp_param(), true);
  CHECK(outer_str_dict_proxy);

  return *inner_str_dict_proxy != *outer_str_dict_proxy;
}

Here is the call graph for this function:

std::vector<Fragmenter_Namespace::FragmentInfo> only_shards_for_device	(	const std::vector< Fragmenter_Namespace::FragmentInfo > &	fragments,
		const int	device_id,
		const int	device_count
	)

Definition at line 316 of file PerfectJoinHashTable.cpp.

References CHECK_GE.

Referenced by PerfectJoinHashTable::reify(), OverlapsJoinHashTable::reifyImpl(), RangeJoinHashTable::reifyWithLayout(), OverlapsJoinHashTable::reifyWithLayout(), and BaselineJoinHashTable::reifyWithLayout().

                            {
  std::vector<Fragmenter_Namespace::FragmentInfo> shards_for_device;
  for (const auto& fragment : fragments) {
    CHECK_GE(fragment.shard, 0);
    if (fragment.shard % device_count == device_id) {
      shards_for_device.push_back(fragment);
    }
  }
  return shards_for_device;
}

Here is the caller graph for this function: