PerfectJoinHashTable Class Reference

#include <PerfectJoinHashTable.h>

Inheritance diagram for PerfectJoinHashTable:

Collaboration diagram for PerfectJoinHashTable:

Classes
struct	AlternativeCacheKeyForPerfectHashJoin

Public Member Functions
std::string	toString (const ExecutorDeviceType device_type, const int device_id=0, bool raw=false) const override
std::set < DecodedJoinHashBufferEntry >	toSet (const ExecutorDeviceType device_type, const int device_id) const override
llvm::Value *	codegenSlot (const CompilationOptions &, const size_t) override
HashJoinMatchingSet	codegenMatchingSet (const CompilationOptions &, const size_t) override
shared::TableKey	getInnerTableId () const noexceptoverride
int	getInnerTableRteIdx () const noexceptoverride
HashType	getHashType () const noexceptoverride
Data_Namespace::MemoryLevel	getMemoryLevel () const noexceptoverride
int	getDeviceCount () const noexceptoverride
size_t	offsetBufferOff () const noexceptoverride
size_t	countBufferOff () const noexceptoverride
size_t	payloadBufferOff () const noexceptoverride
std::string	getHashJoinType () const final
const RegisteredQueryHint &	getRegisteredQueryHint ()
BucketizedHashEntryInfo	getHashEntryInfo () const
size_t	getNormalizedHashEntryCount () const
virtual	~PerfectJoinHashTable ()
Public Member Functions inherited from HashJoin
virtual std::string	toStringFlat64 (const ExecutorDeviceType device_type, const int device_id) const
virtual std::string	toStringFlat32 (const ExecutorDeviceType device_type, const int device_id) const
JoinColumn	fetchJoinColumn (const Analyzer::ColumnVar *hash_col, const std::vector< Fragmenter_Namespace::FragmentInfo > &fragment_info, const Data_Namespace::MemoryLevel effective_memory_level, const int device_id, std::vector< std::shared_ptr< Chunk_NS::Chunk >> &chunks_owner, DeviceAllocator *dev_buff_owner, std::vector< std::shared_ptr< void >> &malloc_owner, Executor *executor, ColumnCacheMap *column_cache)
HashTable *	getHashTableForDevice (const size_t device_id) const
size_t	getJoinHashBufferSize (const ExecutorDeviceType device_type)
size_t	getJoinHashBufferSize (const ExecutorDeviceType device_type, const int device_id) const
int8_t *	getJoinHashBuffer (const ExecutorDeviceType device_type, const int device_id) const
void	freeHashBufferMemory ()

Static Public Member Functions
static std::shared_ptr < PerfectJoinHashTable >	getInstance (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, const JoinType join_type, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor, const HashTableBuildDagMap &hashtable_build_dag_map, const RegisteredQueryHint &query_hints, const TableIdToNodeMap &table_id_to_node_map)
	Make hash table from an in-flight SQL query's parse tree etc. More...
static HashtableRecycler *	getHashTableCache ()
static HashingSchemeRecycler *	getHashingSchemeCache ()
static void	invalidateCache ()
static void	markCachedItemAsDirty (size_t table_key)
Static Public Member Functions inherited from HashJoin
static size_t	getMaximumNumHashEntriesCanHold (MemoryLevel memory_level, const Executor *executor, size_t rowid_size) noexcept
static std::string	generateTooManyHashEntriesErrMsg (size_t num_entries, size_t threshold, MemoryLevel memory_level)
static bool	layoutRequiresAdditionalBuffers (HashType layout) noexcept
static std::string	getHashTypeString (HashType ht) noexcept
static HashJoinMatchingSet	codegenMatchingSet (const std::vector< llvm::Value * > &hash_join_idx_args_in, const bool is_sharded, const bool col_is_nullable, const bool is_bw_eq, const int64_t sub_buff_size, Executor *executor, const bool is_bucketized=false)
static llvm::Value *	codegenHashTableLoad (const size_t table_idx, Executor *executor)
static std::shared_ptr< HashJoin >	getInstance (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, const JoinType join_type, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor, const HashTableBuildDagMap &hashtable_build_dag_map, const RegisteredQueryHint &query_hint, const TableIdToNodeMap &table_id_to_node_map)
	Make hash table from an in-flight SQL query's parse tree etc. More...
static std::shared_ptr< HashJoin >	getSyntheticInstance (std::string_view table1, std::string_view column1, const Catalog_Namespace::Catalog &catalog1, std::string_view table2, std::string_view column2, const Catalog_Namespace::Catalog &catalog2, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)
	Make hash table from named tables and columns (such as for testing). More...
static std::shared_ptr< HashJoin >	getSyntheticInstance (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)
	Make hash table from named tables and columns (such as for testing). More...
static std::pair< std::string, std::shared_ptr< HashJoin > >	getSyntheticInstance (std::vector< std::shared_ptr< Analyzer::BinOper >>, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)
static shared::TableKey	getInnerTableId (const std::vector< InnerOuter > &inner_outer_pairs)
static bool	canAccessHashTable (bool allow_hash_table_recycling, bool invalid_cache_key, JoinType join_type)
static void	checkHashJoinReplicationConstraint (const shared::TableKey &table_key, const size_t shard_count, const Executor *executor)
static std::pair< InnerOuter, InnerOuterStringOpInfos >	normalizeColumnPair (const Analyzer::Expr *lhs, const Analyzer::Expr *rhs, const TemporaryTables *temporary_tables, const bool is_bbox_intersect=false)
template<typename T >
static const T *	getHashJoinColumn (const Analyzer::Expr *expr)
static std::pair< std::vector < InnerOuter >, std::vector < InnerOuterStringOpInfos > >	normalizeColumnPairs (const Analyzer::BinOper *condition, const TemporaryTables *temporary_tables)
static std::vector< int >	collectFragmentIds (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments)
static CompositeKeyInfo	getCompositeKeyInfo (const std::vector< InnerOuter > &inner_outer_pairs, const Executor *executor, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs={})
static std::vector< const StringDictionaryProxy::IdMap * >	translateCompositeStrDictProxies (const CompositeKeyInfo &composite_key_info, const std::vector< InnerOuterStringOpInfos > &string_op_infos_for_keys, const Executor *executor)
static std::pair< const StringDictionaryProxy *, StringDictionaryProxy * >	getStrDictProxies (const InnerOuter &cols, const Executor *executor, const bool has_string_ops)
static const StringDictionaryProxy::IdMap *	translateInnerToOuterStrDictProxies (const InnerOuter &cols, const InnerOuterStringOpInfos &inner_outer_string_op_infos, ExpressionRange &old_col_range, const Executor *executor)

Private Member Functions
bool	isOneToOneHashPossible (const std::vector< ColumnsForDevice > &columns_per_device) const
ColumnsForDevice	fetchColumnsForDevice (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments, const int device_id, DeviceAllocator *dev_buff_owner)
void	reifyForDevice (const ChunkKey &hash_table_key, const ColumnsForDevice &columns_for_device, const HashType layout, const int device_id, const logger::ThreadLocalIds)
int	initHashTableForDevice (const ChunkKey &chunk_key, const JoinColumn &join_column, const InnerOuter &cols, const HashType layout, const Data_Namespace::MemoryLevel effective_memory_level, const int device_id)
Data_Namespace::MemoryLevel	getEffectiveMemoryLevel (const std::vector< InnerOuter > &inner_outer_pairs) const
	PerfectJoinHashTable (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const Analyzer::ColumnVar *col_var, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, const JoinType join_type, const HashType preferred_hash_type, const ExpressionRange &col_range, const ExpressionRange &rhs_source_col_range, const BucketizedHashEntryInfo hash_entry_info, ColumnCacheMap &column_cache, Executor *executor, const int device_count, const RegisteredQueryHint &query_hints, const HashTableBuildDagMap &hashtable_build_dag_map, const TableIdToNodeMap &table_id_to_node_map, const size_t rowid_size, const InnerOuterStringOpInfos &inner_outer_string_op_infos={})
ChunkKey	genChunkKey (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments, const Analyzer::Expr *outer_col, const Analyzer::ColumnVar *inner_col) const
void	reify ()
std::shared_ptr< PerfectHashTable >	initHashTableOnCpuFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier)
void	putHashTableOnCpuToCache (QueryPlanHash key, CacheItemType item_type, std::shared_ptr< PerfectHashTable > hashtable_ptr, DeviceIdentifier device_identifier, size_t hashtable_building_time)
const InputTableInfo &	getInnerQueryInfo (const Analyzer::ColumnVar *inner_col) const
size_t	shardCount () const
llvm::Value *	codegenHashTableLoad (const size_t table_idx)
std::vector< llvm::Value * >	getHashJoinArgs (llvm::Value *hash_ptr, llvm::Value *key_lvs, const Analyzer::Expr *key_col, const int shard_count, const CompilationOptions &co)
bool	isBitwiseEq () const override
size_t	getComponentBufferSize () const noexceptoverride
HashTable *	getHashTableForDevice (const size_t device_id) const
void	copyCpuHashTableToGpu (std::shared_ptr< PerfectHashTable > &cpu_hash_table, const PerfectHashTableEntryInfo hash_table_entry_info, const int device_id, Data_Namespace::DataMgr *data_mgr)

Static Private Member Functions
static QueryPlanHash	getAlternativeCacheKey (AlternativeCacheKeyForPerfectHashJoin &info)

Private Attributes
std::vector< InnerOuter >	inner_outer_pairs_
std::shared_ptr < Analyzer::BinOper >	qual_bin_oper_
const JoinType	join_type_
std::shared_ptr < Analyzer::ColumnVar >	col_var_
const std::vector < InputTableInfo > &	query_infos_
const Data_Namespace::MemoryLevel	memory_level_
HashType	hash_type_
std::mutex	cpu_hash_table_buff_mutex_
std::mutex	str_proxy_translation_mutex_
const StringDictionaryProxy::IdMap *	str_proxy_translation_map_ {nullptr}
ExpressionRange	col_range_
ExpressionRange	rhs_source_col_range_
BucketizedHashEntryInfo	hash_entry_info_
Executor *	executor_
ColumnCacheMap &	column_cache_
const int	device_count_
RegisteredQueryHint	query_hints_
bool	needs_dict_translation_
HashTableBuildDagMap	hashtable_build_dag_map_
std::vector< QueryPlanHash >	hashtable_cache_key_
HashtableCacheMetaInfo	hashtable_cache_meta_info_
std::unordered_set< size_t >	table_keys_
const TableIdToNodeMap	table_id_to_node_map_
const InnerOuterStringOpInfos	inner_outer_string_op_infos_
const size_t	rowid_size_

Static Private Attributes
static std::unique_ptr < HashtableRecycler >	hash_table_cache_
static std::unique_ptr < HashingSchemeRecycler >	hash_table_layout_cache_

Additional Inherited Members
Static Public Attributes inherited from HashJoin
static constexpr size_t	MAX_NUM_HASH_ENTRIES = size_t(1) << 31
Static Protected Member Functions inherited from HashJoin
static llvm::Value *	codegenColOrStringOper (const Analyzer::Expr *col_or_string_oper, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, CodeGenerator &code_generator, const CompilationOptions &co)
Protected Attributes inherited from HashJoin
std::vector< std::shared_ptr < HashTable > >	hash_tables_for_device_

Detailed Description

Definition at line 50 of file PerfectJoinHashTable.h.

Constructor & Destructor Documentation

virtual PerfectJoinHashTable::~PerfectJoinHashTable ( )

inlinevirtual

Definition at line 145 of file PerfectJoinHashTable.h.

{}

PerfectJoinHashTable::PerfectJoinHashTable ( const std::shared_ptr< Analyzer::BinOper >  qual_bin_oper, const Analyzer::ColumnVar *  col_var, const std::vector< InputTableInfo > &  query_infos, const Data_Namespace::MemoryLevel  memory_level, const JoinType  join_type, const HashType  preferred_hash_type, const ExpressionRange &  col_range, const ExpressionRange &  rhs_source_col_range, const BucketizedHashEntryInfo  hash_entry_info, ColumnCacheMap &  column_cache, Executor *  executor, const int  device_count, const RegisteredQueryHint &  query_hints, const HashTableBuildDagMap &  hashtable_build_dag_map, const TableIdToNodeMap &  table_id_to_node_map, const size_t  rowid_size, const InnerOuterStringOpInfos &  inner_outer_string_op_infos = {}  )

inlineprivate

Definition at line 175 of file PerfectJoinHashTable.h.

Referenced by getInstance().

                                                                                    {})
      : qual_bin_oper_(qual_bin_oper)
      , join_type_(join_type)
      , col_var_(std::dynamic_pointer_cast<Analyzer::ColumnVar>(col_var->deep_copy()))
      , query_infos_(query_infos)
      , memory_level_(memory_level)
      , hash_type_(preferred_hash_type)
      , col_range_(col_range)
      , rhs_source_col_range_(rhs_source_col_range)
      , hash_entry_info_(hash_entry_info)
      , executor_(executor)
      , column_cache_(column_cache)
      , device_count_(device_count)
      , query_hints_(query_hints)
      , needs_dict_translation_(false)
      , hashtable_build_dag_map_(hashtable_build_dag_map)
      , table_id_to_node_map_(table_id_to_node_map)
      , inner_outer_string_op_infos_(inner_outer_string_op_infos)
      , rowid_size_(rowid_size) {
    CHECK(col_range.getType() == ExpressionRangeType::Integer);
    CHECK_GT(device_count_, 0);
    hash_tables_for_device_.resize(device_count_);
  }

Here is the caller graph for this function:

Member Function Documentation

llvm::Value * PerfectJoinHashTable::codegenHashTableLoad ( const size_t  table_idx )

private

Definition at line 989 of file PerfectJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, HashJoin::codegenHashTableLoad(), executor_, and get_arg_by_name().

Referenced by codegenMatchingSet(), and codegenSlot().

                                                                            {
  AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
  const auto hash_ptr = HashJoin::codegenHashTableLoad(table_idx, executor_);
  if (hash_ptr->getType()->isIntegerTy(64)) {
    return hash_ptr;
  }
  CHECK(hash_ptr->getType()->isPointerTy());
  return executor_->cgen_state_->ir_builder_.CreatePtrToInt(
      get_arg_by_name(executor_->cgen_state_->row_func_, "join_hash_tables"),
      llvm::Type::getInt64Ty(executor_->cgen_state_->context_));
}

Here is the call graph for this function:

Here is the caller graph for this function:

HashJoinMatchingSet PerfectJoinHashTable::codegenMatchingSet ( const CompilationOptions &  co, const size_t  index  )

overridevirtual

Implements HashJoin.

Definition at line 1055 of file PerfectJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, HashJoin::codegenColOrStringOper(), codegenHashTableLoad(), HashJoin::codegenMatchingSet(), executor_, anonymous_namespace{HashJoin.cpp}::get_cols(), get_max_rte_scan_table(), getComponentBufferSize(), getHashJoinArgs(), inner_outer_string_op_infos_, isBitwiseEq(), kDATE, qual_bin_oper_, self_join_not_covered_by_left_deep_tree(), and shardCount().

                                                                                 {
  AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
  const auto cols = get_cols(qual_bin_oper_.get(), executor_->temporary_tables_).first;
  auto key_col = cols.second;
  CHECK(key_col);
  auto val_col = cols.first;
  CHECK(val_col);
  auto pos_ptr = codegenHashTableLoad(index);
  CHECK(pos_ptr);
  const int shard_count = shardCount();
  const auto key_col_var = dynamic_cast<const Analyzer::ColumnVar*>(key_col);
  const auto val_col_var = dynamic_cast<const Analyzer::ColumnVar*>(val_col);
  if (key_col_var && val_col_var &&
      self_join_not_covered_by_left_deep_tree(
          key_col_var,
          val_col_var,
          get_max_rte_scan_table(executor_->cgen_state_->scan_idx_to_hash_pos_))) {
    throw std::runtime_error(
        "Query execution fails because the query contains not supported self-join "
        "pattern. We suspect the query requires multiple left-deep join tree due to "
        "the "
        "join condition of the self-join and is not supported for now. Please consider "
        "rewriting table order in "
        "FROM clause.");
  }
  CodeGenerator code_generator(executor_);

  auto key_lv = HashJoin::codegenColOrStringOper(
      key_col, inner_outer_string_op_infos_.second, code_generator, co);

  auto hash_join_idx_args = getHashJoinArgs(pos_ptr, key_lv, key_col, shard_count, co);
  const int64_t sub_buff_size = getComponentBufferSize();
  const auto& key_col_ti = key_col->get_type_info();

  auto bucketize = (key_col_ti.get_type() == kDATE);
  return HashJoin::codegenMatchingSet(hash_join_idx_args,
                                      shard_count,
                                      !key_col_ti.get_notnull(),
                                      isBitwiseEq(),
                                      sub_buff_size,
                                      executor_,
                                      bucketize);
}

Here is the call graph for this function:

llvm::Value * PerfectJoinHashTable::codegenSlot ( const CompilationOptions &  co, const size_t  index  )

overridevirtual

Implements HashJoin.

Definition at line 1234 of file PerfectJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, HashJoin::codegenColOrStringOper(), codegenHashTableLoad(), executor_, anonymous_namespace{HashJoin.cpp}::get_cols(), get_max_rte_scan_table(), Analyzer::Expr::get_type_info(), getHashJoinArgs(), getHashType(), isBitwiseEq(), kDATE, OneToOne, qual_bin_oper_, self_join_not_covered_by_left_deep_tree(), and shardCount().

                                                                   {
  AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
  using namespace std::string_literals;

  CHECK(getHashType() == HashType::OneToOne);
  const auto cols_and_string_op_infos =
      get_cols(qual_bin_oper_.get(), executor_->temporary_tables_);
  const auto& cols = cols_and_string_op_infos.first;
  const auto& inner_outer_string_op_infos = cols_and_string_op_infos.second;
  auto key_col = cols.second;
  CHECK(key_col);
  auto val_col = cols.first;
  CHECK(val_col);
  CodeGenerator code_generator(executor_);
  const auto key_col_var = dynamic_cast<const Analyzer::ColumnVar*>(key_col);
  const auto val_col_var = dynamic_cast<const Analyzer::ColumnVar*>(val_col);
  if (key_col_var && val_col_var &&
      self_join_not_covered_by_left_deep_tree(
          key_col_var,
          val_col_var,
          get_max_rte_scan_table(executor_->cgen_state_->scan_idx_to_hash_pos_))) {
    throw std::runtime_error(
        "Query execution failed because the query contains not supported self-join "
        "pattern. We suspect the query requires multiple left-deep join tree due to "
        "the join condition of the self-join and is not supported for now. Please "
        "consider chaning the table order in the FROM clause.");
  }

  auto key_lv = HashJoin::codegenColOrStringOper(
      key_col, inner_outer_string_op_infos.second, code_generator, co);

  // CHECK_EQ(size_t(1), key_lvs.size());
  auto hash_ptr = codegenHashTableLoad(index);
  CHECK(hash_ptr);
  const int shard_count = shardCount();
  const auto hash_join_idx_args =
      getHashJoinArgs(hash_ptr, key_lv, key_col, shard_count, co);

  const auto& key_col_ti = key_col->get_type_info();
  std::string fname((key_col_ti.get_type() == kDATE) ? "bucketized_hash_join_idx"s
                                                     : "hash_join_idx"s);

  if (isBitwiseEq()) {
    fname += "_bitwise";
  }
  if (shard_count) {
    fname += "_sharded";
  }

  if (!isBitwiseEq() && !key_col_ti.get_notnull()) {
    fname += "_nullable";
  }
  return executor_->cgen_state_->emitCall(fname, hash_join_idx_args);
}

Here is the call graph for this function:

void PerfectJoinHashTable::copyCpuHashTableToGpu ( std::shared_ptr< PerfectHashTable > &  cpu_hash_table, const PerfectHashTableEntryInfo  hash_table_entry_info, const int  device_id, Data_Namespace::DataMgr *  data_mgr  )

private

Definition at line 1129 of file PerfectJoinHashTable.cpp.

References PerfectJoinHashTableBuilder::allocateDeviceMemory(), CHECK, CHECK_EQ, CHECK_LT, CPU, cpu_hash_table_buff_mutex_, device_count_, executor_, PerfectJoinHashTableBuilder::getHashTable(), getQueryEngineCudaStreamForDevice(), Data_Namespace::GPU_LEVEL, hash_entry_info_, HashJoin::hash_tables_for_device_, memory_level_, and shardCount().

Referenced by initHashTableForDevice(), and reify().

                                     {
  CHECK_EQ(memory_level_, Data_Namespace::MemoryLevel::GPU_LEVEL);
  CHECK(data_mgr);
  CHECK(cpu_hash_table);

  std::lock_guard<std::mutex> cpu_hash_table_buff_lock(cpu_hash_table_buff_mutex_);
  PerfectJoinHashTableBuilder gpu_builder;
  gpu_builder.allocateDeviceMemory(hash_entry_info_,
                                   hash_table_entry_info,
                                   shardCount(),
                                   device_id,
                                   device_count_,
                                   executor_);

  std::shared_ptr<PerfectHashTable> gpu_hash_table = gpu_builder.getHashTable();
  CHECK(gpu_hash_table);
  auto gpu_buffer_ptr = gpu_hash_table->getGpuBuffer();
  if (gpu_buffer_ptr) {
    auto device_allocator = std::make_unique<CudaAllocator>(
        data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
    device_allocator->copyToDevice(
        gpu_buffer_ptr,
        cpu_hash_table->getCpuBuffer(),
        cpu_hash_table->getHashTableBufferSize(ExecutorDeviceType::CPU));
  }
  CHECK_LT(static_cast<size_t>(device_id), hash_tables_for_device_.size());
  hash_tables_for_device_[device_id] = std::move(gpu_hash_table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t PerfectJoinHashTable::countBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1104 of file PerfectJoinHashTable.cpp.

References getComponentBufferSize().

Referenced by toSet(), and toString().

                                                           {
  return getComponentBufferSize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ColumnsForDevice PerfectJoinHashTable::fetchColumnsForDevice ( const std::vector< Fragmenter_Namespace::FragmentInfo > &  fragments, const int  device_id, DeviceAllocator *  dev_buff_owner  )

private

Definition at line 720 of file PerfectJoinHashTable.cpp.

References column_cache_, executor_, HashJoin::fetchJoinColumn(), get_column_descriptor_maybe(), get_effective_memory_level(), get_join_column_type_kind(), inline_fixed_encoding_null_val(), inner_outer_pairs_, isBitwiseEq(), memory_level_, and needs_dict_translation_.

Referenced by reify().

                                     {
  std::vector<JoinColumn> join_columns;
  std::vector<std::shared_ptr<Chunk_NS::Chunk>> chunks_owner;
  std::vector<JoinColumnTypeInfo> join_column_types;
  std::vector<JoinBucketInfo> join_bucket_info;
  std::vector<std::shared_ptr<void>> malloc_owner;
  const auto effective_memory_level =
      get_effective_memory_level(memory_level_, needs_dict_translation_);
  for (const auto& inner_outer_pair : inner_outer_pairs_) {
    const auto inner_col = inner_outer_pair.first;
    const auto inner_cd = get_column_descriptor_maybe(inner_col->getColumnKey());
    if (inner_cd && inner_cd->isVirtualCol) {
      throw FailedToJoinOnVirtualColumn();
    }
    join_columns.emplace_back(fetchJoinColumn(inner_col,
                                              fragments,
                                              effective_memory_level,
                                              device_id,
                                              chunks_owner,
                                              dev_buff_owner,
                                              malloc_owner,
                                              executor_,
                                              &column_cache_));
    const auto& ti = inner_col->get_type_info();
    join_column_types.emplace_back(JoinColumnTypeInfo{static_cast<size_t>(ti.get_size()),
                                                      0,
                                                      0,
                                                      inline_fixed_encoding_null_val(ti),
                                                      isBitwiseEq(),
                                                      0,
                                                      get_join_column_type_kind(ti)});
  }
  return {join_columns, join_column_types, chunks_owner, join_bucket_info, malloc_owner};
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChunkKey PerfectJoinHashTable::genChunkKey ( const std::vector< Fragmenter_Namespace::FragmentInfo > &  fragments, const Analyzer::Expr *  outer_col, const Analyzer::ColumnVar *  inner_col  ) const

private

Definition at line 927 of file PerfectJoinHashTable.cpp.

References gpu_enabled::accumulate(), CHECK, CHECK_EQ, shared::ColumnKey::db_id, Analyzer::Expr::get_type_info(), Analyzer::ColumnVar::getColumnKey(), getInnerQueryInfo(), InputTableInfo::info, and kENCODING_DICT.

Referenced by reify().

                                              {
  const auto& column_key = inner_col->getColumnKey();
  ChunkKey chunk_key{column_key.db_id, column_key.table_id, column_key.column_id};
  const auto& ti = inner_col->get_type_info();
  std::for_each(fragments.cbegin(), fragments.cend(), [&chunk_key](const auto& fragment) {
    // collect all frag ids to correctly generated cache key for a cached hash table
    chunk_key.push_back(fragment.fragmentId);
  });
  if (ti.is_string()) {
    CHECK_EQ(kENCODING_DICT, ti.get_compression());
    const auto outer_col = dynamic_cast<const Analyzer::ColumnVar*>(outer_col_expr);
    CHECK(outer_col);
    const auto& outer_query_info = getInnerQueryInfo(outer_col).info;
    size_t outer_elem_count =
        std::accumulate(outer_query_info.fragments.begin(),
                        outer_query_info.fragments.end(),
                        size_t(0),
                        [&chunk_key](size_t sum, const auto& fragment) {
                          chunk_key.push_back(fragment.fragmentId);
                          return sum + fragment.getNumTuples();
                        });
    chunk_key.push_back(outer_elem_count);
  }

  return chunk_key;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static QueryPlanHash PerfectJoinHashTable::getAlternativeCacheKey ( AlternativeCacheKeyForPerfectHashJoin &  info )

inlinestaticprivate

Definition at line 264 of file PerfectJoinHashTable.h.

References PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::chunk_key, PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::col_range, Analyzer::Expr::get_type_info(), hash_value(), PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::inner_col, PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::inner_outer_string_op_infos, SQLTypeInfo::is_string(), PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::join_type, PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::num_elements, PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::optype, PerfectJoinHashTable::AlternativeCacheKeyForPerfectHashJoin::outer_col, toString(), ExpressionRange::toString(), and Analyzer::ColumnVar::toString().

Referenced by reify().

                                                   {
    auto hash = boost::hash_value(::toString(info.chunk_key));
    boost::hash_combine(hash, info.inner_col->toString());
    if (info.inner_col->get_type_info().is_string()) {
      boost::hash_combine(hash, info.outer_col->toString());
    }
    boost::hash_combine(hash, ::toString(info.inner_outer_string_op_infos));
    boost::hash_combine(hash, info.col_range.toString());
    boost::hash_combine(hash, info.num_elements);
    boost::hash_combine(hash, info.optype);
    boost::hash_combine(hash, info.join_type);
    return hash;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t PerfectJoinHashTable::getComponentBufferSize ( ) const

overrideprivatevirtualnoexcept

Implements HashJoin.

Definition at line 1112 of file PerfectJoinHashTable.cpp.

References HashJoin::hash_tables_for_device_, and OneToMany.

Referenced by codegenMatchingSet(), countBufferOff(), and payloadBufferOff().

                                                                   {
  if (hash_tables_for_device_.empty()) {
    return 0;
  }
  auto hash_table = hash_tables_for_device_.front();
  if (hash_table && hash_table->getLayout() == HashType::OneToMany) {
    return hash_table->getEntryCount() * sizeof(int32_t);
  } else {
    return 0;
  }
}

Here is the caller graph for this function:

int PerfectJoinHashTable::getDeviceCount ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 92 of file PerfectJoinHashTable.h.

References device_count_.

{ return device_count_; };

Data_Namespace::MemoryLevel PerfectJoinHashTable::getEffectiveMemoryLevel ( const std::vector< InnerOuter > &  inner_outer_pairs ) const

private

Definition at line 710 of file PerfectJoinHashTable.cpp.

References Data_Namespace::CPU_LEVEL, executor_, inner_outer_string_op_infos_, memory_level_, needs_dict_translation_, and needs_dictionary_translation().

Referenced by reify().

                                                          {
  if (needs_dictionary_translation(
          inner_outer_pairs.front(), inner_outer_string_op_infos_, executor_)) {
    needs_dict_translation_ = true;
    return Data_Namespace::CPU_LEVEL;
  }
  return memory_level_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BucketizedHashEntryInfo PerfectJoinHashTable::getHashEntryInfo ( ) const

inline

Definition at line 139 of file PerfectJoinHashTable.h.

References hash_entry_info_.

{ return hash_entry_info_; }

static HashingSchemeRecycler* PerfectJoinHashTable::getHashingSchemeCache ( )

inlinestatic

Definition at line 106 of file PerfectJoinHashTable.h.

References CHECK, and hash_table_layout_cache_.

                                                        {
    CHECK(hash_table_layout_cache_);
    return hash_table_layout_cache_.get();
  }

std::vector< llvm::Value * > PerfectJoinHashTable::getHashJoinArgs ( llvm::Value *  hash_ptr, llvm::Value *  key_lvs, const Analyzer::Expr *  key_col, const int  shard_count, const CompilationOptions &  co  )

private

Definition at line 1001 of file PerfectJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, BucketizedHashEntryInfo::bucket_normalization, CHECK, col_range_, device_count_, executor_, anonymous_namespace{PerfectJoinHashTable.cpp}::get_hash_entry_count(), get_logical_type_info(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), hash_entry_info_, inline_fixed_encoding_null_val(), isBitwiseEq(), and kDATE.

Referenced by codegenMatchingSet(), and codegenSlot().

                                  {
  AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
  CodeGenerator code_generator(executor_);
  CHECK(key_lv);
  // Todo(todd): Fix below, it's gross (but didn't want to redo the plumbing yet)
  // const auto key_lv = key_lvs.size() && key_lvs[0]
  //                        ? key_lvs[0]
  //                        : code_generator.codegen(key_col, true, co)[0];
  auto const& key_col_ti = key_col->get_type_info();

  std::vector<llvm::Value*> hash_join_idx_args{
      hash_ptr,
      executor_->cgen_state_->castToTypeIn(key_lv, 64),
      executor_->cgen_state_->llInt(col_range_.getIntMin()),
      executor_->cgen_state_->llInt(col_range_.getIntMax())};
  if (shard_count) {
    const auto expected_hash_entry_count =
        get_hash_entry_count(col_range_, isBitwiseEq());
    const auto entry_count_per_shard =
        (expected_hash_entry_count + shard_count - 1) / shard_count;
    hash_join_idx_args.push_back(
        executor_->cgen_state_->llInt<uint32_t>(entry_count_per_shard));
    hash_join_idx_args.push_back(executor_->cgen_state_->llInt<uint32_t>(shard_count));
    hash_join_idx_args.push_back(executor_->cgen_state_->llInt<uint32_t>(device_count_));
  }
  auto key_col_logical_ti = get_logical_type_info(key_col->get_type_info());
  if (!key_col_logical_ti.get_notnull() || isBitwiseEq()) {
    hash_join_idx_args.push_back(executor_->cgen_state_->llInt(
        inline_fixed_encoding_null_val(key_col_logical_ti)));
  }
  auto special_date_bucketization_case = key_col_ti.get_type() == kDATE;
  if (isBitwiseEq()) {
    if (special_date_bucketization_case) {
      hash_join_idx_args.push_back(executor_->cgen_state_->llInt(
          col_range_.getIntMax() / hash_entry_info_.bucket_normalization + 1));
    } else {
      hash_join_idx_args.push_back(
          executor_->cgen_state_->llInt(col_range_.getIntMax() + 1));
    }
  }

  if (special_date_bucketization_case) {
    hash_join_idx_args.emplace_back(
        executor_->cgen_state_->llInt(hash_entry_info_.bucket_normalization));
  }

  return hash_join_idx_args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string PerfectJoinHashTable::getHashJoinType ( ) const

inlinefinalvirtual

Implements HashJoin.

Definition at line 100 of file PerfectJoinHashTable.h.

{ return "Perfect"; }

static HashtableRecycler* PerfectJoinHashTable::getHashTableCache ( )

inlinestatic

Definition at line 102 of file PerfectJoinHashTable.h.

References CHECK, and hash_table_cache_.

Referenced by QueryRunner::QueryRunner::getCachedHashtableWithoutCacheKey(), QueryRunner::QueryRunner::getCacheItemMetric(), QueryRunner::QueryRunner::getNumberOfCachedItem(), anonymous_namespace{DBHandler.cpp}::log_cache_size(), and CommandLineOptions::parse_command_line().

                                                {
    CHECK(hash_table_cache_);
    return hash_table_cache_.get();
  }

Here is the caller graph for this function:

HashTable * PerfectJoinHashTable::getHashTableForDevice ( const size_t  device_id ) const

private

Definition at line 1124 of file PerfectJoinHashTable.cpp.

References CHECK_LT, and HashJoin::hash_tables_for_device_.

Referenced by toSet(), and toString().

                                                                                   {
  CHECK_LT(device_id, hash_tables_for_device_.size());
  return hash_tables_for_device_[device_id].get();
}

Here is the caller graph for this function:

HashType PerfectJoinHashTable::getHashType ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 86 of file PerfectJoinHashTable.h.

References hash_type_.

Referenced by codegenSlot().

{ return hash_type_; }

Here is the caller graph for this function:

const InputTableInfo & PerfectJoinHashTable::getInnerQueryInfo ( const Analyzer::ColumnVar *  inner_col ) const

private

Definition at line 1290 of file PerfectJoinHashTable.cpp.

References get_inner_query_info(), Analyzer::ColumnVar::getTableKey(), and query_infos_.

Referenced by genChunkKey(), and reify().

                                              {
  return get_inner_query_info(inner_col->getTableKey(), query_infos_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

shared::TableKey PerfectJoinHashTable::getInnerTableId ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 78 of file PerfectJoinHashTable.h.

References col_var_.

Referenced by reify().

                                                           {
    return col_var_->getTableKey();
  };

Here is the caller graph for this function:

int PerfectJoinHashTable::getInnerTableRteIdx ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 82 of file PerfectJoinHashTable.h.

References col_var_.

                                                    {
    return col_var_.get()->get_rte_idx();
  };

std::shared_ptr< PerfectJoinHashTable > PerfectJoinHashTable::getInstance ( const std::shared_ptr< Analyzer::BinOper >  qual_bin_oper, const std::vector< InputTableInfo > &  query_infos, const Data_Namespace::MemoryLevel  memory_level, const JoinType  join_type, const HashType  preferred_hash_type, const int  device_count, ColumnCacheMap &  column_cache, Executor *  executor, const HashTableBuildDagMap &  hashtable_build_dag_map, const RegisteredQueryHint &  query_hints, const TableIdToNodeMap &  table_id_to_node_map  )

static

Make hash table from an in-flight SQL query's parse tree etc.

Definition at line 168 of file PerfectJoinHashTable.cpp.

References CHECK, CHECK_EQ, RegisteredQueryHint::force_one_to_many_hash_join, g_is_test_env, g_num_tuple_threshold_switch_to_baseline, g_ratio_num_hash_entry_to_num_tuple_switch_to_baseline, HashJoin::generateTooManyHashEntriesErrMsg(), anonymous_namespace{PerfectJoinHashTable.cpp}::get_bucketized_hash_entry_info(), anonymous_namespace{HashJoin.cpp}::get_cols(), get_inner_query_info(), getExpressionRange(), HashJoin::getHashTypeString(), HashJoin::getMaximumNumHashEntriesCanHold(), BucketizedHashEntryInfo::getNormalizedHashEntryCount(), logger::INFO, Invalid, IS_EQUIVALENCE, kBW_EQ, LOG, ExpressionRange::makeIntRange(), OneToMany, PerfectJoinHashTable(), VLOG, and VLOGGING.

Referenced by HashJoin::getInstance().

                                                  {
  CHECK(IS_EQUIVALENCE(qual_bin_oper->get_optype()));
  const auto cols_and_string_op_infos =
      get_cols(qual_bin_oper.get(), executor->temporary_tables_);
  const auto& cols = cols_and_string_op_infos.first;
  const auto& inner_outer_string_op_infos = cols_and_string_op_infos.second;
  const auto inner_col = cols.first;
  CHECK(inner_col);
  const auto& ti = inner_col->get_type_info();
  auto col_range =
      getExpressionRange(ti.is_string() ? cols.second : inner_col, query_infos, executor);
  if (col_range.getType() == ExpressionRangeType::Invalid) {
    throw HashJoinFail(
        "Could not compute range for the expressions involved in the equijoin");
  }
  const auto rhs_source_col_range =
      ti.is_string() ? getExpressionRange(inner_col, query_infos, executor) : col_range;
  if (ti.is_string()) {
    // The nullable info must be the same as the source column.
    if (rhs_source_col_range.getType() == ExpressionRangeType::Invalid) {
      throw HashJoinFail(
          "Could not compute range for the expressions involved in the equijoin");
    }
    if (rhs_source_col_range.getIntMin() > rhs_source_col_range.getIntMax()) {
      // If the inner column expression range is empty, use the inner col range
      CHECK_EQ(rhs_source_col_range.getIntMin(), int64_t(0));
      CHECK_EQ(rhs_source_col_range.getIntMax(), int64_t(-1));
      col_range = rhs_source_col_range;
    } else {
      col_range = ExpressionRange::makeIntRange(
          std::min(rhs_source_col_range.getIntMin(), col_range.getIntMin()),
          std::max(rhs_source_col_range.getIntMax(), col_range.getIntMax()),
          0,
          rhs_source_col_range.hasNulls());
    }
  }
  auto bucketized_entry_count_info = get_bucketized_hash_entry_info(
      ti, col_range, qual_bin_oper->get_optype() == kBW_EQ);
  auto bucketized_entry_count = bucketized_entry_count_info.getNormalizedHashEntryCount();
  size_t const rowid_size = sizeof(int32_t);
  auto const max_num_hash_entries =
      HashJoin::getMaximumNumHashEntriesCanHold(memory_level, executor, rowid_size);
  if (bucketized_entry_count > max_num_hash_entries) {
    throw TooManyHashEntries(HashJoin::generateTooManyHashEntriesErrMsg(
        bucketized_entry_count, max_num_hash_entries, memory_level));
  }

  auto const& inner_table_info =
      get_inner_query_info(inner_col->getTableKey(), query_infos).info;
  auto const num_inner_table_tuple = inner_table_info.getFragmentNumTuplesUpperBound();
  // when a table is small but has too wide hash entry value range, it's better to deploy
  // baseline hash join to save unnecessary memory space and expensive hash table
  // initialization & building cost required to build a perfect join hash table
  auto const deploy_baseline_join =
      !g_is_test_env &&
      num_inner_table_tuple < g_num_tuple_threshold_switch_to_baseline &&
      num_inner_table_tuple * g_ratio_num_hash_entry_to_num_tuple_switch_to_baseline <
          bucketized_entry_count;
  if (deploy_baseline_join) {
    std::ostringstream oss;
    oss << "Switch to baseline hash join: a join column has too wide hash value range "
           "when comparing the actual # rows";
    oss << "(# hash entries: " << bucketized_entry_count
        << ", # rows: " << num_inner_table_tuple << ")";
    throw TooManyHashEntries(oss.str());
  }

  if (qual_bin_oper->get_optype() == kBW_EQ &&
      col_range.getIntMax() >= std::numeric_limits<int64_t>::max()) {
    throw HashJoinFail("Cannot translate null value for kBW_EQ");
  }
  decltype(std::chrono::steady_clock::now()) ts1, ts2;
  if (VLOGGING(1)) {
    ts1 = std::chrono::steady_clock::now();
  }
  auto hash_type = preferred_hash_type;
  if (query_hints.force_one_to_many_hash_join) {
    LOG(INFO) << "A user's query hint forced the join operation to use OneToMany hash "
                 "join layout";
    hash_type = HashType::OneToMany;
  }
  auto join_hash_table = std::shared_ptr<PerfectJoinHashTable>(
      new PerfectJoinHashTable(qual_bin_oper,
                               inner_col,
                               query_infos,
                               memory_level,
                               join_type,
                               hash_type,
                               col_range,
                               rhs_source_col_range,
                               bucketized_entry_count_info,
                               column_cache,
                               executor,
                               device_count,
                               query_hints,
                               hashtable_build_dag_map,
                               table_id_to_node_map,
                               rowid_size,
                               inner_outer_string_op_infos));
  try {
    join_hash_table->reify();
  } catch (const TableMustBeReplicated& e) {
    // Throw a runtime error to abort the query
    join_hash_table->freeHashBufferMemory();
    throw std::runtime_error(e.what());
  } catch (const HashJoinFail& e) {
    // HashJoinFail exceptions log an error and trigger a retry with a join loop (if
    // possible)
    join_hash_table->freeHashBufferMemory();
    throw HashJoinFail(std::string("Could not build a 1-to-1 correspondence for columns "
                                   "involved in equijoin | ") +
                       e.what());
  } catch (const ColumnarConversionNotSupported& e) {
    throw HashJoinFail(std::string("Could not build hash tables for equijoin | ") +
                       e.what());
  } catch (const OutOfMemory& e) {
    throw HashJoinFail(
        std::string("Ran out of memory while building hash tables for equijoin | ") +
        e.what());
  } catch (const JoinHashTableTooBig& e) {
    throw e;
  } catch (const std::exception& e) {
    throw std::runtime_error(
        std::string("Fatal error while attempting to build hash tables for join: ") +
        e.what());
  }
  if (VLOGGING(1)) {
    ts2 = std::chrono::steady_clock::now();
    VLOG(1) << "Built perfect hash table "
            << getHashTypeString(join_hash_table->getHashType()) << " in "
            << std::chrono::duration_cast<std::chrono::milliseconds>(ts2 - ts1).count()
            << " ms";
  }
  return join_hash_table;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Data_Namespace::MemoryLevel PerfectJoinHashTable::getMemoryLevel ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 88 of file PerfectJoinHashTable.h.

References memory_level_.

                                                                     {
    return memory_level_;
  };

size_t PerfectJoinHashTable::getNormalizedHashEntryCount ( ) const

inline

Definition at line 141 of file PerfectJoinHashTable.h.

References BucketizedHashEntryInfo::getNormalizedHashEntryCount(), and hash_entry_info_.

Referenced by initHashTableForDevice(), and isOneToOneHashPossible().

                                             {
    return hash_entry_info_.getNormalizedHashEntryCount();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

const RegisteredQueryHint& PerfectJoinHashTable::getRegisteredQueryHint ( )

inline

Definition at line 137 of file PerfectJoinHashTable.h.

References query_hints_.

{ return query_hints_; }

int PerfectJoinHashTable::initHashTableForDevice ( const ChunkKey &  chunk_key, const JoinColumn &  join_column, const InnerOuter &  cols, const HashType  layout, const Data_Namespace::MemoryLevel  effective_memory_level, const int  device_id  )

private

Definition at line 796 of file PerfectJoinHashTable.cpp.

References PerfectJoinHashTableBuilder::allocateDeviceMemory(), CHECK, CHECK_EQ, CHECK_LT, col_range_, copyCpuHashTableToGpu(), CPU, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, cpu_hash_table_buff_mutex_, Data_Namespace::CPU_LEVEL, DEBUG_TIMER, device_count_, executor_, PerfectJoinHashTableBuilder::getHashTable(), getNormalizedHashEntryCount(), Data_Namespace::GPU_LEVEL, hash_entry_info_, HashJoin::hash_tables_for_device_, hashtable_cache_key_, PerfectJoinHashTableBuilder::initOneToManyHashTableOnCpu(), PerfectJoinHashTableBuilder::initOneToOneHashTableOnCpu(), inner_outer_string_op_infos_, isBitwiseEq(), RegisteredQueryHint::isHintRegistered(), HashtableRecycler::isSafeToCacheHashtable(), join_type_, kMaxJoinHashTableSize, RegisteredQueryHint::max_join_hash_table_size, memory_level_, needs_dict_translation_, JoinColumn::num_elems, OneToOne, PERFECT_HT, putHashTableOnCpuToCache(), query_hints_, rowid_size_, shardCount(), str_proxy_translation_map_, table_id_to_node_map_, UNREACHABLE, and WINDOW_FUNCTION_FRAMING.

Referenced by reifyForDevice().

                         {
  auto timer = DEBUG_TIMER(__func__);
  const auto inner_col = cols.first;
  CHECK(inner_col);
#ifndef HAVE_CUDA
  CHECK_EQ(Data_Namespace::CPU_LEVEL, effective_memory_level);
#endif
  int err{0};
  const int32_t hash_join_invalid_val{-1};
  auto hashtable_layout = layout;
  auto allow_hashtable_recycling =
      HashtableRecycler::isSafeToCacheHashtable(table_id_to_node_map_,
                                                needs_dict_translation_,
                                                {inner_outer_string_op_infos_},
                                                inner_col->getTableKey());
  PerfectHashTableEntryInfo hash_table_entry_info(
      getNormalizedHashEntryCount(),
      join_column.num_elems,
      rowid_size_,
      hashtable_layout,
      join_type_ == JoinType::WINDOW_FUNCTION_FRAMING);
  auto const hash_table_size = hash_table_entry_info.computeHashTableSize();
  if (query_hints_.isHintRegistered(QueryHint::kMaxJoinHashTableSize) &&
      hash_table_size > query_hints_.max_join_hash_table_size) {
    throw JoinHashTableTooBig(hash_table_size, query_hints_.max_join_hash_table_size);
  }
  if (memory_level_ == Data_Namespace::GPU_LEVEL &&
      hash_table_size > executor_->maxGpuSlabSize()) {
    throw JoinHashTableTooBig(hash_table_size, executor_->maxGpuSlabSize());
  }
  if (effective_memory_level == Data_Namespace::CPU_LEVEL) {
    CHECK(!chunk_key.empty());
    std::shared_ptr<PerfectHashTable> hash_table{nullptr};
    decltype(std::chrono::steady_clock::now()) ts1, ts2;
    ts1 = std::chrono::steady_clock::now();
    {
      std::lock_guard<std::mutex> cpu_hash_table_buff_lock(cpu_hash_table_buff_mutex_);
      PerfectJoinHashTableBuilder builder;
      if (hashtable_layout == HashType::OneToOne) {
        builder.initOneToOneHashTableOnCpu(join_column,
                                           col_range_,
                                           isBitwiseEq(),
                                           cols,
                                           str_proxy_translation_map_,
                                           join_type_,
                                           hash_entry_info_,
                                           hash_table_entry_info,
                                           hash_join_invalid_val,
                                           executor_);
        hash_table = builder.getHashTable();
      } else {
        builder.initOneToManyHashTableOnCpu(join_column,
                                            col_range_,
                                            isBitwiseEq(),
                                            cols,
                                            str_proxy_translation_map_,
                                            join_type_,
                                            hash_entry_info_,
                                            hash_table_entry_info,
                                            hash_join_invalid_val,
                                            executor_);
        hash_table = builder.getHashTable();
      }
      ts2 = std::chrono::steady_clock::now();
      auto build_time =
          std::chrono::duration_cast<std::chrono::milliseconds>(ts2 - ts1).count();
      hash_table->setHashEntryInfo(hash_entry_info_);
      hash_table->setColumnNumElems(join_column.num_elems);
      if (allow_hashtable_recycling && hash_table &&
          hash_table->getHashTableBufferSize(ExecutorDeviceType::CPU) > 0) {
        putHashTableOnCpuToCache(hashtable_cache_key_[device_id],
                                 CacheItemType::PERFECT_HT,
                                 hash_table,
                                 DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                                 build_time);
      }
    }
    // Transfer the hash table on the GPU if we've only built it on CPU
    // but the query runs on GPU (join on dictionary encoded columns).
    if (memory_level_ == Data_Namespace::GPU_LEVEL) {
#ifdef HAVE_CUDA
      const auto& ti = inner_col->get_type_info();
      CHECK(ti.is_string());
      auto data_mgr = executor_->getDataMgr();
      copyCpuHashTableToGpu(hash_table, hash_table_entry_info, device_id, data_mgr);
#else
      UNREACHABLE();
#endif
    } else {
      CHECK(hash_table);
      CHECK_LT(static_cast<size_t>(device_id), hash_tables_for_device_.size());
      hash_tables_for_device_[device_id] = hash_table;
    }
  } else {
#ifdef HAVE_CUDA
    PerfectJoinHashTableBuilder builder;
    CHECK_EQ(Data_Namespace::GPU_LEVEL, effective_memory_level);
    builder.allocateDeviceMemory(hash_entry_info_,
                                 hash_table_entry_info,
                                 shardCount(),
                                 device_id,
                                 device_count_,
                                 executor_);
    builder.initHashTableOnGpu(chunk_key,
                               join_column,
                               col_range_,
                               isBitwiseEq(),
                               cols,
                               join_type_,
                               hash_entry_info_,
                               hash_table_entry_info,
                               shardCount(),
                               hash_join_invalid_val,
                               device_id,
                               device_count_,
                               executor_);
    CHECK_LT(static_cast<size_t>(device_id), hash_tables_for_device_.size());
    hash_tables_for_device_[device_id] = builder.getHashTable();
#else
    UNREACHABLE();
#endif
  }
  return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< PerfectHashTable > PerfectJoinHashTable::initHashTableOnCpuFromCache ( QueryPlanHash  key, CacheItemType  item_type, DeviceIdentifier  device_identifier  )

private

Definition at line 957 of file PerfectJoinHashTable.cpp.

References CHECK, DEBUG_TIMER, hash_table_cache_, and VLOG.

Referenced by reify().

                                        {
  CHECK(hash_table_cache_);
  auto timer = DEBUG_TIMER(__func__);
  VLOG(1) << "Checking CPU hash table cache.";
  auto hashtable_ptr =
      hash_table_cache_->getItemFromCache(key, item_type, device_identifier);
  if (hashtable_ptr) {
    return std::dynamic_pointer_cast<PerfectHashTable>(hashtable_ptr);
  }
  return nullptr;
}

Here is the caller graph for this function:

static void PerfectJoinHashTable::invalidateCache ( )

inlinestatic

Definition at line 111 of file PerfectJoinHashTable.h.

References CHECK, hash_table_cache_, and hash_table_layout_cache_.

                                {
    CHECK(hash_table_layout_cache_);
    hash_table_layout_cache_->clearCache();

    CHECK(hash_table_cache_);
    hash_table_cache_->clearCache();
  }

bool PerfectJoinHashTable::isBitwiseEq ( ) const

overrideprivatevirtual

Implements HashJoin.

Definition at line 1316 of file PerfectJoinHashTable.cpp.

References kBW_EQ, and qual_bin_oper_.

Referenced by codegenMatchingSet(), codegenSlot(), fetchColumnsForDevice(), getHashJoinArgs(), initHashTableForDevice(), and reify().

                                             {
  return qual_bin_oper_->get_optype() == kBW_EQ;
}

Here is the caller graph for this function:

bool PerfectJoinHashTable::isOneToOneHashPossible ( const std::vector< ColumnsForDevice > &  columns_per_device ) const

private

Definition at line 376 of file PerfectJoinHashTable.cpp.

References CHECK, anonymous_namespace{PerfectJoinHashTable.cpp}::get_bucketized_hash_entry_info(), getNormalizedHashEntryCount(), ExpressionRange::hasNulls(), inner_outer_pairs_, kBW_EQ, qual_bin_oper_, rhs_source_col_range_, and VLOG.

Referenced by reify().

                                                                 {
  CHECK(!inner_outer_pairs_.empty());
  const auto& rhs_col_ti = inner_outer_pairs_.front().first->get_type_info();
  const auto max_unique_hash_input_entries =
      get_bucketized_hash_entry_info(
          rhs_col_ti, rhs_source_col_range_, qual_bin_oper_->get_optype() == kBW_EQ)
          .getNormalizedHashEntryCount() +
      rhs_source_col_range_.hasNulls();
  for (const auto& device_columns : columns_per_device) {
    CHECK(!device_columns.join_columns.empty());
    const auto rhs_join_col_num_entries = device_columns.join_columns.front().num_elems;
    if (rhs_join_col_num_entries > max_unique_hash_input_entries) {
      VLOG(1) << "Skipping attempt to build perfect hash one-to-one table as number of "
                 "rhs column entries ("
              << rhs_join_col_num_entries << ") exceeds range for rhs join column ("
              << max_unique_hash_input_entries << ").";
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void PerfectJoinHashTable::markCachedItemAsDirty ( size_t  table_key )

inlinestatic

Definition at line 119 of file PerfectJoinHashTable.h.

References CHECK, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, hash_table_cache_, hash_table_layout_cache_, HT_HASHING_SCHEME, and PERFECT_HT.

                                                      {
    CHECK(hash_table_layout_cache_);
    CHECK(hash_table_cache_);
    auto candidate_table_keys =
        hash_table_cache_->getMappedQueryPlanDagsWithTableKey(table_key);
    if (candidate_table_keys.has_value()) {
      hash_table_layout_cache_->markCachedItemAsDirty(
          table_key,
          *candidate_table_keys,
          CacheItemType::HT_HASHING_SCHEME,
          DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
      hash_table_cache_->markCachedItemAsDirty(table_key,
                                               *candidate_table_keys,
                                               CacheItemType::PERFECT_HT,
                                               DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
    }
  }

size_t PerfectJoinHashTable::offsetBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1100 of file PerfectJoinHashTable.cpp.

Referenced by toSet(), and toString().

                                                            {
  return 0;
}

Here is the caller graph for this function:

size_t PerfectJoinHashTable::payloadBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1108 of file PerfectJoinHashTable.cpp.

References getComponentBufferSize().

Referenced by toSet(), and toString().

                                                             {
  return 2 * getComponentBufferSize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PerfectJoinHashTable::putHashTableOnCpuToCache ( QueryPlanHash  key, CacheItemType  item_type, std::shared_ptr< PerfectHashTable >  hashtable_ptr, DeviceIdentifier  device_identifier, size_t  hashtable_building_time  )

private

Definition at line 972 of file PerfectJoinHashTable.cpp.

References CHECK, CPU, and hash_table_cache_.

Referenced by initHashTableForDevice().

                                    {
  CHECK(hash_table_cache_);
  CHECK(hashtable_ptr && !hashtable_ptr->getGpuBuffer());
  hash_table_cache_->putItemToCache(
      key,
      hashtable_ptr,
      item_type,
      device_identifier,
      hashtable_ptr->getHashTableBufferSize(ExecutorDeviceType::CPU),
      hashtable_building_time);
}

Here is the caller graph for this function:

void PerfectJoinHashTable::reify ( )

private

Definition at line 399 of file PerfectJoinHashTable.cpp.

References gpu_enabled::accumulate(), anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), threading_serial::async(), HashJoin::canAccessHashTable(), CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, HashJoin::checkHashJoinReplicationConstraint(), col_range_, copyCpuHashTableToGpu(), DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, Data_Namespace::CPU_LEVEL, DEBUG_TIMER, device_count_, executor_, fetchColumnsForDevice(), HashJoin::freeHashBufferMemory(), genChunkKey(), anonymous_namespace{PerfectJoinHashTable.cpp}::get_bucketized_hash_entry_info(), anonymous_namespace{HashJoin.cpp}::get_cols(), get_shard_count(), getAlternativeCacheKey(), DataRecyclerUtil::getAlternativeTableKeys(), getEffectiveMemoryLevel(), HashtableRecycler::getHashtableAccessPathInfo(), getInnerQueryInfo(), getInnerTableId(), getQueryEngineCudaStreamForDevice(), Data_Namespace::GPU_LEVEL, hash_entry_info_, hash_table_cache_, hash_table_layout_cache_, HashJoin::hash_tables_for_device_, hash_type_, hashtable_build_dag_map_, hashtable_cache_key_, hashtable_cache_meta_info_, HT_HASHING_SCHEME, InputTableInfo::info, initHashTableOnCpuFromCache(), inner_outer_pairs_, inner_outer_string_op_infos_, isBitwiseEq(), HashtableRecycler::isInvalidHashTableCacheKey(), isOneToOneHashPossible(), HashtableRecycler::isSafeToCacheHashtable(), join_type_, HashJoin::MAX_NUM_HASH_ENTRIES, memory_level_, needs_dict_translation_, needs_dictionary_translation(), OneToMany, OneToOne, only_shards_for_device(), PERFECT_HT, qual_bin_oper_, reifyForDevice(), shardCount(), str_proxy_translation_map_, str_proxy_translation_mutex_, shared::TableKey::table_id, table_id_to_node_map_, table_keys_, logger::thread_local_ids(), HashJoin::translateInnerToOuterStrDictProxies(), UNREACHABLE, and VLOG.

                                 {
  auto timer = DEBUG_TIMER(__func__);
  CHECK_LT(0, device_count_);
  const auto cols = get_cols(qual_bin_oper_.get(), executor_->temporary_tables_).first;
  const auto inner_col = cols.first;
  HashJoin::checkHashJoinReplicationConstraint(
      inner_col->getTableKey(),
      get_shard_count(qual_bin_oper_.get(), executor_),
      executor_);
  const auto& query_info = getInnerQueryInfo(inner_col).info;
  if (query_info.fragments.empty()) {
    return;
  }
  if (query_info.getNumTuplesUpperBound() > HashJoin::MAX_NUM_HASH_ENTRIES) {
    throw TooManyHashEntries();
  }
  std::vector<std::future<void>> init_threads;
  const int shard_count = shardCount();

  inner_outer_pairs_.push_back(cols);
  CHECK_EQ(inner_outer_pairs_.size(), size_t(1));
  // Todo(todd): Clean up the fact that we store the inner outer column pairs as a vector,
  // even though only one is ever valid for perfect hash layout. Either move to 1 or keep
  // the vector but move it to the HashTable parent class
  needs_dict_translation_ = needs_dictionary_translation(
      inner_outer_pairs_.front(), inner_outer_string_op_infos_, executor_);

  std::vector<std::vector<Fragmenter_Namespace::FragmentInfo>> fragments_per_device;
  std::vector<ColumnsForDevice> columns_per_device;
  std::vector<std::unique_ptr<CudaAllocator>> dev_buff_owners;

  auto data_mgr = executor_->getDataMgr();
  // check the existence of cached hash table here before fetching columns
  // if available, skip the rest of logic and copy it to GPU if necessary
  // there are few considerable things:
  // 1. if table is sharded? --> deploy per-device logic
  // here, each device may load different set of fragments, so their cache keys are
  // different accordingly
  // 2. otherwise, each device has the same hash table built from "all" fragments
  // and their cache keys are the same (but we stick to per-device cache key vector)
  // here, for CPU, we consider its # device to be one
  // for GPU, each device builds its own hash table, or we build a single hash table on
  // CPU and then copy it to each device
  // 3. if cache key is not available? --> use alternative cache key

  // retrieve fragment lists and chunk key per device
  std::vector<ChunkKey> chunk_key_per_device;
  auto outer_col =
      dynamic_cast<const Analyzer::ColumnVar*>(inner_outer_pairs_.front().second);
  for (int device_id = 0; device_id < device_count_; ++device_id) {
    fragments_per_device.emplace_back(
        shard_count
            ? only_shards_for_device(query_info.fragments, device_id, device_count_)
            : query_info.fragments);
    if (memory_level_ == Data_Namespace::MemoryLevel::GPU_LEVEL) {
      dev_buff_owners.emplace_back(std::make_unique<CudaAllocator>(
          data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id)));
    }
    const auto chunk_key =
        genChunkKey(fragments_per_device[device_id], outer_col, inner_col);
    chunk_key_per_device.emplace_back(std::move(chunk_key));
  }

  // try to extract cache key for hash table and its relevant info
  auto hashtable_access_path_info =
      HashtableRecycler::getHashtableAccessPathInfo(inner_outer_pairs_,
                                                    {inner_outer_string_op_infos_},
                                                    qual_bin_oper_->get_optype(),
                                                    join_type_,
                                                    hashtable_build_dag_map_,
                                                    device_count_,
                                                    shard_count,
                                                    fragments_per_device,
                                                    executor_);
  hashtable_cache_key_ = hashtable_access_path_info.hashed_query_plan_dag;
  hashtable_cache_meta_info_ = hashtable_access_path_info.meta_info;
  table_keys_ = hashtable_access_path_info.table_keys;

  if (table_keys_.empty()) {
    // the actual chunks fetched per device can be different but they constitute the same
    // table in the same db, so we can exploit this to create an alternative table key
    const auto& inner_table_key = getInnerTableId();
    table_keys_ =
        DataRecyclerUtil::getAlternativeTableKeys(chunk_key_per_device, inner_table_key);
  }
  CHECK(!table_keys_.empty());

  if (HashtableRecycler::isInvalidHashTableCacheKey(hashtable_cache_key_) &&
      getInnerTableId().table_id > 0) {
    // sometimes we cannot retrieve query plan dag, so try to recycler cache
    // with the old-fashioned cache key if we deal with hashtable of non-temporary table
    for (int device_id = 0; device_id < device_count_; ++device_id) {
      const auto num_tuples = std::accumulate(
          fragments_per_device[device_id].begin(),
          fragments_per_device[device_id].end(),
          size_t(0),
          [](size_t sum, const auto& fragment) { return sum + fragment.getNumTuples(); });
      AlternativeCacheKeyForPerfectHashJoin cache_key{col_range_,
                                                      inner_col,
                                                      outer_col ? outer_col : inner_col,
                                                      inner_outer_string_op_infos_,
                                                      chunk_key_per_device[device_id],
                                                      num_tuples,
                                                      qual_bin_oper_->get_optype(),
                                                      join_type_};
      hashtable_cache_key_[device_id] = getAlternativeCacheKey(cache_key);
    }
  }

  // register a mapping between cache key and its input table info for per-table cache
  // invalidation if we have valid cache key for "all" devices (otherwise, we skip to use
  // cached hash table for safety)
  auto allow_hashtable_recycling =
      HashtableRecycler::isSafeToCacheHashtable(table_id_to_node_map_,
                                                needs_dict_translation_,
                                                {inner_outer_string_op_infos_},
                                                inner_col->getTableKey());
  const bool invalid_cache_key =
      HashtableRecycler::isInvalidHashTableCacheKey(hashtable_cache_key_);
  if (!invalid_cache_key && allow_hashtable_recycling) {
    if (!shard_count) {
      hash_table_cache_->addQueryPlanDagForTableKeys(hashtable_cache_key_.front(),
                                                     table_keys_);
    } else {
      std::for_each(hashtable_cache_key_.cbegin(),
                    hashtable_cache_key_.cend(),
                    [this](QueryPlanHash key) {
                      hash_table_cache_->addQueryPlanDagForTableKeys(key, table_keys_);
                    });
    }
    auto found_cached_one_to_many_layout = std::any_of(
        hashtable_cache_key_.cbegin(),
        hashtable_cache_key_.cend(),
        [](QueryPlanHash cache_key) {
          auto cached_hashtable_layout_type = hash_table_layout_cache_->getItemFromCache(
              cache_key,
              CacheItemType::HT_HASHING_SCHEME,
              DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
              {});
          return cached_hashtable_layout_type &&
                 *cached_hashtable_layout_type == HashType::OneToMany;
        });
    if (found_cached_one_to_many_layout) {
      // we need to sync hash_type for all devices
      hash_type_ = HashType::OneToMany;
    }
  }

  const auto effective_memory_level = getEffectiveMemoryLevel(inner_outer_pairs_);

  // Assume we will need one-to-many if we have a string operation, as these tend
  // to be cardinality-reducting operations, i.e. |S(t)| < |t|
  // Todo(todd): Ostensibly only string ops on the rhs/inner expression cause rhs dups and
  // so we may be too conservative here, but validate

  const bool has_string_ops = inner_outer_string_op_infos_.first.size() ||
                              inner_outer_string_op_infos_.second.size();

  // Also check if on the number of entries per column exceeds the rhs join hash table
  // range, and skip trying to build a One-to-One hash table if so. There is a slight edge
  // case where this can be overly pessimistic, and that is if the non-null values are all
  // unique, but there are multiple null values, but we currently don't have the metadata
  // to track null counts (only column nullability from the ddl and null existence from
  // the encoded data), and this is probably too much of an edge case to worry about for
  // now given the general performance benfits of skipping 1:1 if we are fairly confident
  // it is doomed up front

  // Now check if on the number of entries per column exceeds the rhs join hash table
  // range, and skip trying to build a One-to-One hash table if so
  if (hash_type_ == HashType::OneToOne &&
      (has_string_ops || !isOneToOneHashPossible(columns_per_device))) {
    hash_type_ = HashType::OneToMany;
  }

  // todo (yoonmin) : support dictionary proxy cache for join including string op(s)
  if (effective_memory_level == Data_Namespace::CPU_LEVEL) {
    // construct string dictionary proxies if necessary
    std::unique_lock<std::mutex> str_proxy_translation_lock(str_proxy_translation_mutex_);
    if (needs_dict_translation_ && !str_proxy_translation_map_) {
      CHECK_GE(inner_outer_pairs_.size(), 1UL);
      auto const copied_col_range = col_range_;
      str_proxy_translation_map_ =
          HashJoin::translateInnerToOuterStrDictProxies(inner_outer_pairs_.front(),
                                                        inner_outer_string_op_infos_,
                                                        col_range_,
                                                        executor_);
      // update hash entry info if necessary
      if (!(col_range_ == copied_col_range)) {
        hash_entry_info_ = get_bucketized_hash_entry_info(
            inner_col->get_type_info(), col_range_, isBitwiseEq());
      }
    }
  }
  bool has_invalid_cached_hash_table = false;
  if (effective_memory_level == Data_Namespace::CPU_LEVEL &&
      HashJoin::canAccessHashTable(
          allow_hashtable_recycling, invalid_cache_key, join_type_)) {
    // build a hash table on CPU, and we have a chance to recycle the cached one if
    // available
    for (int device_id = 0; device_id < device_count_; ++device_id) {
      auto hash_table =
          initHashTableOnCpuFromCache(hashtable_cache_key_[device_id],
                                      CacheItemType::PERFECT_HT,
                                      DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
      if (hash_table) {
        hash_tables_for_device_[device_id] = hash_table;
        hash_type_ = hash_table->getLayout();
      } else {
        has_invalid_cached_hash_table = true;
        break;
      }
    }

    if (has_invalid_cached_hash_table) {
      hash_tables_for_device_.clear();
      hash_tables_for_device_.resize(device_count_);
    } else {
      if (memory_level_ == Data_Namespace::GPU_LEVEL) {
#ifdef HAVE_CUDA
        for (int device_id = 0; device_id < device_count_; ++device_id) {
          auto cpu_hash_table = std::dynamic_pointer_cast<PerfectHashTable>(
              hash_tables_for_device_[device_id]);
          copyCpuHashTableToGpu(cpu_hash_table,
                                cpu_hash_table->getHashTableEntryInfo(),
                                device_id,
                                data_mgr);
        }
#else
        UNREACHABLE();
#endif
      }
      return;
    }
  }

  // we have no cached hash table for this qual
  // so, start building the hash table by fetching columns for devices
  for (int device_id = 0; device_id < device_count_; ++device_id) {
    columns_per_device.emplace_back(
        fetchColumnsForDevice(fragments_per_device[device_id],
                              device_id,
                              memory_level_ == Data_Namespace::MemoryLevel::GPU_LEVEL
                                  ? dev_buff_owners[device_id].get()
                                  : nullptr));
  }

  try {
    for (int device_id = 0; device_id < device_count_; ++device_id) {
      const auto chunk_key = genChunkKey(fragments_per_device[device_id],
                                         inner_outer_pairs_.front().second,
                                         inner_outer_pairs_.front().first);
      init_threads.push_back(std::async(std::launch::async,
                                        &PerfectJoinHashTable::reifyForDevice,
                                        this,
                                        chunk_key,
                                        columns_per_device[device_id],
                                        hash_type_,
                                        device_id,
                                        logger::thread_local_ids()));
    }
    for (auto& init_thread : init_threads) {
      init_thread.wait();
    }
    for (auto& init_thread : init_threads) {
      init_thread.get();
    }
  } catch (const NeedsOneToManyHash& e) {
    VLOG(1) << "RHS/Inner hash join values detected to not be unique, falling back to "
               "One-to-Many hash layout.";
    hash_type_ = HashType::OneToMany;
    freeHashBufferMemory();
    init_threads.clear();
    if (memory_level_ == Data_Namespace::MemoryLevel::GPU_LEVEL) {
      CHECK_EQ(dev_buff_owners.size(), size_t(device_count_));
    }
    CHECK_EQ(columns_per_device.size(), size_t(device_count_));
    for (int device_id = 0; device_id < device_count_; ++device_id) {
      const auto chunk_key = genChunkKey(fragments_per_device[device_id],
                                         inner_outer_pairs_.front().second,
                                         inner_outer_pairs_.front().first);
      init_threads.push_back(std::async(std::launch::async,
                                        &PerfectJoinHashTable::reifyForDevice,
                                        this,
                                        chunk_key,
                                        columns_per_device[device_id],
                                        hash_type_,
                                        device_id,
                                        logger::thread_local_ids()));
    }
    for (auto& init_thread : init_threads) {
      init_thread.wait();
    }
    for (auto& init_thread : init_threads) {
      init_thread.get();
    }
  }
  for (int device_id = 0; device_id < device_count_; ++device_id) {
    auto const cache_key = hashtable_cache_key_[device_id];
    auto const hash_table_ptr = hash_tables_for_device_[device_id];
    if (hash_table_ptr) {
      hash_table_layout_cache_->putItemToCache(cache_key,
                                               hash_table_ptr->getLayout(),
                                               CacheItemType::HT_HASHING_SCHEME,
                                               DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                                               0,
                                               0,
                                               {});
    }
  }
}

Here is the call graph for this function:

void PerfectJoinHashTable::reifyForDevice ( const ChunkKey &  hash_table_key, const ColumnsForDevice &  columns_for_device, const HashType  layout, const int  device_id, const logger::ThreadLocalIds  parent_thread_local_ids  )

private

Definition at line 758 of file PerfectJoinHashTable.cpp.

References CHECK_EQ, DEBUG_TIMER_NEW_THREAD, get_effective_memory_level(), initHashTableForDevice(), inner_outer_pairs_, ColumnsForDevice::join_columns, memory_level_, needs_dict_translation_, OneToMany, OneToOne, logger::ThreadLocalIds::setNewThreadId(), logger::ThreadLocalIds::thread_id_, and to_string().

Referenced by reify().

                                                        {
  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
  DEBUG_TIMER_NEW_THREAD(parent_thread_local_ids.thread_id_);
  const auto effective_memory_level =
      get_effective_memory_level(memory_level_, needs_dict_translation_);

  CHECK_EQ(columns_for_device.join_columns.size(), size_t(1));
  CHECK_EQ(inner_outer_pairs_.size(), size_t(1));
  auto& join_column = columns_for_device.join_columns.front();
  if (layout == HashType::OneToOne) {
    const auto err = initHashTableForDevice(chunk_key,
                                            join_column,
                                            inner_outer_pairs_.front(),
                                            layout,
                                            effective_memory_level,
                                            device_id);
    if (err) {
      throw NeedsOneToManyHash();
    }
  } else {
    const auto err = initHashTableForDevice(chunk_key,
                                            join_column,
                                            inner_outer_pairs_.front(),
                                            HashType::OneToMany,
                                            effective_memory_level,
                                            device_id);
    if (err) {
      throw std::runtime_error("Unexpected error building one to many hash table: " +
                               std::to_string(err));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t PerfectJoinHashTable::shardCount ( ) const

private

Definition at line 1310 of file PerfectJoinHashTable.cpp.

References executor_, get_shard_count(), Data_Namespace::GPU_LEVEL, memory_level_, and qual_bin_oper_.

Referenced by codegenMatchingSet(), codegenSlot(), copyCpuHashTableToGpu(), initHashTableForDevice(), and reify().

                                              {
  return memory_level_ == Data_Namespace::GPU_LEVEL
             ? get_shard_count(qual_bin_oper_.get(), executor_)
             : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::set< DecodedJoinHashBufferEntry > PerfectJoinHashTable::toSet ( const ExecutorDeviceType  device_type, const int  device_id  ) const

overridevirtual

Implements HashJoin.

Definition at line 1201 of file PerfectJoinHashTable.cpp.

References countBufferOff(), executor_, getHashTableForDevice(), HashJoin::getJoinHashBuffer(), HashJoin::getJoinHashBufferSize(), getQueryEngineCudaStreamForDevice(), GPU, offsetBufferOff(), payloadBufferOff(), and HashTable::toSet().

                               {
  auto buffer = getJoinHashBuffer(device_type, device_id);
  auto buffer_size = getJoinHashBufferSize(device_type, device_id);
  auto hash_table = getHashTableForDevice(device_id);
#ifdef HAVE_CUDA
  std::unique_ptr<int8_t[]> buffer_copy;
  if (device_type == ExecutorDeviceType::GPU) {
    buffer_copy = std::make_unique<int8_t[]>(buffer_size);

    auto data_mgr = executor_->getDataMgr();
    auto device_allocator = std::make_unique<CudaAllocator>(
        data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
    device_allocator->copyFromDevice(buffer_copy.get(), buffer, buffer_size);
  }
  auto ptr1 = buffer_copy ? buffer_copy.get() : reinterpret_cast<const int8_t*>(buffer);
#else
  auto ptr1 = reinterpret_cast<const int8_t*>(buffer);
#endif  // HAVE_CUDA
  auto ptr2 = ptr1 + offsetBufferOff();
  auto ptr3 = ptr1 + countBufferOff();
  auto ptr4 = ptr1 + payloadBufferOff();
  return HashTable::toSet(0,
                          0,
                          hash_table ? hash_table->getEntryCount() : 0,
                          ptr1,
                          ptr2,
                          ptr3,
                          ptr4,
                          buffer_size);
}

Here is the call graph for this function:

std::string PerfectJoinHashTable::toString ( const ExecutorDeviceType  device_type, const int  device_id = 0, bool  raw = false  ) const

overridevirtual

Implements HashJoin.

Definition at line 1162 of file PerfectJoinHashTable.cpp.

References countBufferOff(), executor_, getHashTableForDevice(), HashJoin::getHashTypeString(), HashJoin::getJoinHashBuffer(), HashJoin::getJoinHashBufferSize(), getQueryEngineCudaStreamForDevice(), GPU, hash_type_, offsetBufferOff(), payloadBufferOff(), and HashTable::toString().

Referenced by getAlternativeCacheKey().

                                                           {
  auto buffer = getJoinHashBuffer(device_type, device_id);
  if (!buffer) {
    return "EMPTY";
  }
  auto buffer_size = getJoinHashBufferSize(device_type, device_id);
  auto hash_table = getHashTableForDevice(device_id);
#ifdef HAVE_CUDA
  std::unique_ptr<int8_t[]> buffer_copy;
  if (device_type == ExecutorDeviceType::GPU) {
    buffer_copy = std::make_unique<int8_t[]>(buffer_size);

    auto data_mgr = executor_->getDataMgr();
    auto device_allocator = std::make_unique<CudaAllocator>(
        data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
    device_allocator->copyFromDevice(buffer_copy.get(), buffer, buffer_size);
  }
  auto ptr1 = buffer_copy ? buffer_copy.get() : reinterpret_cast<const int8_t*>(buffer);
#else
  auto ptr1 = reinterpret_cast<const int8_t*>(buffer);
#endif  // HAVE_CUDA
  auto ptr2 = ptr1 + offsetBufferOff();
  auto ptr3 = ptr1 + countBufferOff();
  auto ptr4 = ptr1 + payloadBufferOff();
  return HashTable::toString("perfect",
                             getHashTypeString(hash_type_),
                             0,
                             0,
                             hash_table ? hash_table->getEntryCount() : 0,
                             ptr1,
                             ptr2,
                             ptr3,
                             ptr4,
                             buffer_size,
                             raw);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

ExpressionRange PerfectJoinHashTable::col_range_

private

Definition at line 288 of file PerfectJoinHashTable.h.

Referenced by getHashJoinArgs(), initHashTableForDevice(), and reify().

std::shared_ptr<Analyzer::ColumnVar> PerfectJoinHashTable::col_var_

private

Definition at line 281 of file PerfectJoinHashTable.h.

Referenced by getInnerTableId(), and getInnerTableRteIdx().

ColumnCacheMap& PerfectJoinHashTable::column_cache_

private

Definition at line 292 of file PerfectJoinHashTable.h.

Referenced by fetchColumnsForDevice().

std::mutex PerfectJoinHashTable::cpu_hash_table_buff_mutex_

private

Definition at line 285 of file PerfectJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), and initHashTableForDevice().

const int PerfectJoinHashTable::device_count_

private

Definition at line 293 of file PerfectJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), getDeviceCount(), getHashJoinArgs(), initHashTableForDevice(), and reify().

Executor* PerfectJoinHashTable::executor_

private

Definition at line 291 of file PerfectJoinHashTable.h.

Referenced by codegenHashTableLoad(), codegenMatchingSet(), codegenSlot(), copyCpuHashTableToGpu(), fetchColumnsForDevice(), getEffectiveMemoryLevel(), getHashJoinArgs(), initHashTableForDevice(), reify(), shardCount(), toSet(), and toString().

BucketizedHashEntryInfo PerfectJoinHashTable::hash_entry_info_

mutableprivate

Definition at line 290 of file PerfectJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), getHashEntryInfo(), getHashJoinArgs(), getNormalizedHashEntryCount(), initHashTableForDevice(), and reify().

std::unique_ptr< HashtableRecycler > PerfectJoinHashTable::hash_table_cache_

staticprivate

Initial value:

=
    std::make_unique<HashtableRecycler>(CacheItemType::PERFECT_HT,
                                        DataRecyclerUtil::CPU_DEVICE_IDENTIFIER)

Definition at line 305 of file PerfectJoinHashTable.h.

Referenced by getHashTableCache(), initHashTableOnCpuFromCache(), invalidateCache(), markCachedItemAsDirty(), putHashTableOnCpuToCache(), and reify().

std::unique_ptr< HashingSchemeRecycler > PerfectJoinHashTable::hash_table_layout_cache_

staticprivate

Initial value:

=
    std::make_unique<HashingSchemeRecycler>()

Definition at line 306 of file PerfectJoinHashTable.h.

Referenced by getHashingSchemeCache(), invalidateCache(), markCachedItemAsDirty(), and reify().

HashType PerfectJoinHashTable::hash_type_

private

Definition at line 284 of file PerfectJoinHashTable.h.

Referenced by getHashType(), reify(), and toString().

HashTableBuildDagMap PerfectJoinHashTable::hashtable_build_dag_map_

private

Definition at line 296 of file PerfectJoinHashTable.h.

Referenced by reify().

std::vector<QueryPlanHash> PerfectJoinHashTable::hashtable_cache_key_

private

Definition at line 298 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

HashtableCacheMetaInfo PerfectJoinHashTable::hashtable_cache_meta_info_

private

Definition at line 299 of file PerfectJoinHashTable.h.

Referenced by reify().

std::vector<InnerOuter> PerfectJoinHashTable::inner_outer_pairs_

private

Definition at line 173 of file PerfectJoinHashTable.h.

Referenced by fetchColumnsForDevice(), isOneToOneHashPossible(), reify(), and reifyForDevice().

const InnerOuterStringOpInfos PerfectJoinHashTable::inner_outer_string_op_infos_

private

Definition at line 302 of file PerfectJoinHashTable.h.

Referenced by codegenMatchingSet(), getEffectiveMemoryLevel(), initHashTableForDevice(), and reify().

const JoinType PerfectJoinHashTable::join_type_

private

Definition at line 280 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

const Data_Namespace::MemoryLevel PerfectJoinHashTable::memory_level_

private

Definition at line 283 of file PerfectJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), fetchColumnsForDevice(), getEffectiveMemoryLevel(), getMemoryLevel(), initHashTableForDevice(), reify(), reifyForDevice(), and shardCount().

bool PerfectJoinHashTable::needs_dict_translation_

mutableprivate

Definition at line 295 of file PerfectJoinHashTable.h.

Referenced by fetchColumnsForDevice(), getEffectiveMemoryLevel(), initHashTableForDevice(), reify(), and reifyForDevice().

std::shared_ptr<Analyzer::BinOper> PerfectJoinHashTable::qual_bin_oper_

private

Definition at line 279 of file PerfectJoinHashTable.h.

Referenced by codegenMatchingSet(), codegenSlot(), isBitwiseEq(), isOneToOneHashPossible(), reify(), and shardCount().

RegisteredQueryHint PerfectJoinHashTable::query_hints_

private

Definition at line 294 of file PerfectJoinHashTable.h.

Referenced by getRegisteredQueryHint(), and initHashTableForDevice().

const std::vector<InputTableInfo>& PerfectJoinHashTable::query_infos_

private

Definition at line 282 of file PerfectJoinHashTable.h.

Referenced by getInnerQueryInfo().

ExpressionRange PerfectJoinHashTable::rhs_source_col_range_

private

Definition at line 289 of file PerfectJoinHashTable.h.

Referenced by isOneToOneHashPossible().

const size_t PerfectJoinHashTable::rowid_size_

private

Definition at line 303 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice().

const StringDictionaryProxy::IdMap* PerfectJoinHashTable::str_proxy_translation_map_ {nullptr}

private

Definition at line 287 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

std::mutex PerfectJoinHashTable::str_proxy_translation_mutex_

private

Definition at line 286 of file PerfectJoinHashTable.h.

Referenced by reify().

const TableIdToNodeMap PerfectJoinHashTable::table_id_to_node_map_

private

Definition at line 301 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

std::unordered_set<size_t> PerfectJoinHashTable::table_keys_

private

Definition at line 300 of file PerfectJoinHashTable.h.

Referenced by reify().

---

The documentation for this class was generated from the following files:

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