#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 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_overlaps_join=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 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 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_

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

static std::unique_ptr < HashingSchemeRecycler >	hash_table_layout_cache_

Additional Inherited Members
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.

145 {}

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 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) {
     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 951 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 1017 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 1196 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 int	device_id,
		Data_Namespace::DataMgr *	data_mgr
	)

private

Definition at line 1091 of file PerfectJoinHashTable.cpp.

References PerfectJoinHashTableBuilder::allocateDeviceMemory(), CHECK, CHECK_EQ, CHECK_LE, CHECK_LT, CPU, cpu_hash_table_buff_mutex_, device_count_, executor_, PerfectJoinHashTableBuilder::getHashTable(), getQueryEngineCudaStreamForDevice(), GPU, Data_Namespace::GPU_LEVEL, 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(cpu_hash_table->getColumnNumElems(),
                                    cpu_hash_table->getLayout(),
                                    cpu_hash_table->getHashEntryInfo(),
                                    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();
   CHECK(gpu_buffer_ptr);
 
   CHECK_LE(cpu_hash_table->getHashTableBufferSize(ExecutorDeviceType::CPU),
            gpu_hash_table->getHashTableBufferSize(ExecutorDeviceType::GPU));
 
   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 1066 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 651 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 889 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 261 of file PerfectJoinHashTable.h.

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 1074 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_.

92 { return device_count_; };

PerfectJoinHashTable::device_count_

const int device_count_

Definition: PerfectJoinHashTable.h:290

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

private

Definition at line 641 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_.

139 { return hash_entry_info_; }

PerfectJoinHashTable::hash_entry_info_

BucketizedHashEntryInfo hash_entry_info_

Definition: PerfectJoinHashTable.h:287

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 963 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.

100 { 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(), and QueryRunner::QueryRunner::getNumberOfCachedItem().

                                                 {
     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 1086 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().

86 { return hash_type_; }

PerfectJoinHashTable::hash_type_

HashType hash_type_

Definition: PerfectJoinHashTable.h:281

Here is the caller graph for this function:

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

private

Definition at line 1252 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 151 of file PerfectJoinHashTable.cpp.

References CHECK, CHECK_EQ, anonymous_namespace{PerfectJoinHashTable.cpp}::get_bucketized_hash_entry_info(), anonymous_namespace{HashJoin.cpp}::get_cols(), getExpressionRange(), HashJoin::getHashTypeString(), BucketizedHashEntryInfo::getNormalizedHashEntryCount(), Data_Namespace::GPU_LEVEL, Invalid, IS_EQUIVALENCE, kBW_EQ, ExpressionRange::makeIntRange(), 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());
     }
   }
 
   // We can't allocate more than 2GB contiguous memory on GPU and each entry is 4 bytes.
   const auto max_hash_entry_count =
       memory_level == Data_Namespace::MemoryLevel::GPU_LEVEL
           ? static_cast<size_t>(std::numeric_limits<int32_t>::max() / sizeof(int32_t))
           : static_cast<size_t>(std::numeric_limits<int32_t>::max());
 
   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();
   if (bucketized_entry_count > max_hash_entry_count) {
     throw TooManyHashEntries();
   }
 
   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 join_hash_table = std::shared_ptr<PerfectJoinHashTable>(
       new PerfectJoinHashTable(qual_bin_oper,
                                inner_col,
                                query_infos,
                                memory_level,
                                join_type,
                                preferred_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,
                                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_.

137 { return query_hints_; }

PerfectJoinHashTable::query_hints_

RegisteredQueryHint query_hints_

Definition: PerfectJoinHashTable.h:291

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 728 of file PerfectJoinHashTable.cpp.

References PerfectJoinHashTableBuilder::allocateDeviceMemory(), BucketizedHashEntryInfo::bucketized_hash_entry_count, CHECK, CHECK_EQ, CHECK_LT, col_range_, copyCpuHashTableToGpu(), 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_, hash_table_layout_cache_, HashJoin::hash_tables_for_device_, hash_type_, hashtable_cache_key_, HT_HASHING_SCHEME, 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_, shardCount(), str_proxy_translation_map_, table_id_to_node_map_, UNREACHABLE, and VLOG.

Referenced by reifyForDevice().

                          {
   auto timer = DEBUG_TIMER(__func__);
   const auto inner_col = cols.first;
   CHECK(inner_col);
   if (hash_entry_info_.bucketized_hash_entry_count == 0 && layout == HashType::OneToOne) {
     // the reason of why checking the layout is OneToOne is we start to build a hash table
     // with OneToOne layout
     VLOG(1) << "Stop building a hash table based on a column " << inner_col->toString()
             << ": it is from an empty table";
     return 0;
   }
 #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());
   if (allow_hashtable_recycling) {
     auto cached_hashtable_layout_type = hash_table_layout_cache_->getItemFromCache(
         hashtable_cache_key_[device_id],
         CacheItemType::HT_HASHING_SCHEME,
         DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
         {});
     if (cached_hashtable_layout_type) {
       hash_type_ = *cached_hashtable_layout_type;
       hashtable_layout = hash_type_;
     }
   }
   const auto entry_count = getNormalizedHashEntryCount();
   const auto hash_table_entry_count = hashtable_layout == HashType::OneToOne
                                           ? entry_count
                                           : 2 * entry_count + join_column.num_elems;
   const auto hash_table_size = hash_table_entry_count * sizeof(int32_t);
   if (query_hints_.isHintRegistered(QueryHint::kMaxJoinHashTableSize) &&
       join_column.num_elems > query_hints_.max_join_hash_table_size) {
     throw JoinHashTableTooBig(hash_table_size, query_hints_.max_join_hash_table_size);
   }
   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_,
                                            hashtable_layout,
                                            hash_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_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) {
         // add ht-related items to cache iff we have a valid hashtable
         hash_table_layout_cache_->putItemToCache(hashtable_cache_key_[device_id],
                                                  hashtable_layout,
                                                  CacheItemType::HT_HASHING_SCHEME,
                                                  DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                                                  0,
                                                  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, 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(join_column,
                                  hashtable_layout,
                                  hash_entry_info_,
                                  shardCount(),
                                  device_id,
                                  device_count_,
                                  executor_);
     builder.initHashTableOnGpu(chunk_key,
                                join_column,
                                col_range_,
                                isBitwiseEq(),
                                cols,
                                join_type_,
                                hashtable_layout,
                                hash_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();
     if (!err && allow_hashtable_recycling && hash_tables_for_device_[device_id]) {
       // add layout to cache iff we have a valid hashtable
       hash_table_layout_cache_->putItemToCache(
           hashtable_cache_key_[device_id],
           hash_tables_for_device_[device_id]->getLayout(),
           CacheItemType::HT_HASHING_SCHEME,
           DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
           0,
           0,
           {});
     }
 #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 919 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 1292 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 336 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 1062 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 1070 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 934 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 359 of file PerfectJoinHashTable.cpp.

References gpu_enabled::accumulate(), 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_, HashJoin::hash_tables_for_device_, hash_type_, hashtable_build_dag_map_, hashtable_cache_key_, hashtable_cache_meta_info_, InputTableInfo::info, initHashTableOnCpuFromCache(), inner_outer_pairs_, inner_outer_string_op_infos_, isBitwiseEq(), HashtableRecycler::isInvalidHashTableCacheKey(), isOneToOneHashPossible(), HashtableRecycler::isSafeToCacheHashtable(), join_type_, 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() >
       static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     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)
   const bool invalid_cache_key =
       HashtableRecycler::isInvalidHashTableCacheKey(hashtable_cache_key_);
   if (!invalid_cache_key) {
     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_);
                     });
     }
   }
 
   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());
       }
     }
   }
 
   auto allow_hashtable_recycling =
       HashtableRecycler::isSafeToCacheHashtable(table_id_to_node_map_,
                                                 needs_dict_translation_,
                                                 {inner_outer_string_op_infos_},
                                                 inner_col->getTableKey());
   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, 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.";
     CHECK(hash_type_ == HashType::OneToOne);
     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();
     }
   }
 }

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 689 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 1286 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 1163 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 1127 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);
   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 285 of file PerfectJoinHashTable.h.

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

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

private

Definition at line 278 of file PerfectJoinHashTable.h.

Referenced by getInnerTableId(), and getInnerTableRteIdx().

ColumnCacheMap& PerfectJoinHashTable::column_cache_

private

Definition at line 289 of file PerfectJoinHashTable.h.

Referenced by fetchColumnsForDevice().

std::mutex PerfectJoinHashTable::cpu_hash_table_buff_mutex_

private

Definition at line 282 of file PerfectJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), and initHashTableForDevice().

const int PerfectJoinHashTable::device_count_

private

Definition at line 290 of file PerfectJoinHashTable.h.

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

Executor* PerfectJoinHashTable::executor_

private

Definition at line 288 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 287 of file PerfectJoinHashTable.h.

Referenced by 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 301 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 302 of file PerfectJoinHashTable.h.

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

HashType PerfectJoinHashTable::hash_type_

private

Definition at line 281 of file PerfectJoinHashTable.h.

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

HashTableBuildDagMap PerfectJoinHashTable::hashtable_build_dag_map_

private

Definition at line 293 of file PerfectJoinHashTable.h.

Referenced by reify().

std::vector<QueryPlanHash> PerfectJoinHashTable::hashtable_cache_key_

private

Definition at line 295 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

HashtableCacheMetaInfo PerfectJoinHashTable::hashtable_cache_meta_info_

private

Definition at line 296 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 299 of file PerfectJoinHashTable.h.

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

const JoinType PerfectJoinHashTable::join_type_

private

Definition at line 277 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

const Data_Namespace::MemoryLevel PerfectJoinHashTable::memory_level_

private

Definition at line 280 of file PerfectJoinHashTable.h.

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

bool PerfectJoinHashTable::needs_dict_translation_

mutableprivate

Definition at line 292 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 276 of file PerfectJoinHashTable.h.

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

RegisteredQueryHint PerfectJoinHashTable::query_hints_

private

Definition at line 291 of file PerfectJoinHashTable.h.

Referenced by getRegisteredQueryHint(), and initHashTableForDevice().

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

private

Definition at line 279 of file PerfectJoinHashTable.h.

Referenced by getInnerQueryInfo().

ExpressionRange PerfectJoinHashTable::rhs_source_col_range_

private

Definition at line 286 of file PerfectJoinHashTable.h.

Referenced by isOneToOneHashPossible().

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

private

Definition at line 284 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

std::mutex PerfectJoinHashTable::str_proxy_translation_mutex_

private

Definition at line 283 of file PerfectJoinHashTable.h.

Referenced by reify().

const TableIdToNodeMap PerfectJoinHashTable::table_id_to_node_map_

private

Definition at line 298 of file PerfectJoinHashTable.h.

Referenced by initHashTableForDevice(), and reify().

std::unordered_set<size_t> PerfectJoinHashTable::table_keys_

private

Definition at line 297 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

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation