#include <BaselineJoinHashTable.h>

Inheritance diagram for BaselineJoinHashTable:

Collaboration diagram for BaselineJoinHashTable:

Classes
struct	AlternativeCacheKeyForBaselineHashJoin

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 ()

virtual	~BaselineJoinHashTable ()

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 < BaselineJoinHashTable >	getInstance (const std::shared_ptr< Analyzer::BinOper > condition, 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 size_t	getShardCountForCondition (const Analyzer::BinOper condition, const Executor executor, const std::vector< InnerOuter > &inner_outer_pairs)

static void	invalidateCache ()

static void	markCachedItemAsDirty (size_t table_key)

static HashtableRecycler *	getHashTableCache ()

static HashingSchemeRecycler *	getHashingSchemeCache ()

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)

Protected Member Functions
	BaselineJoinHashTable (const std::shared_ptr< Analyzer::BinOper > condition, const JoinType join_type, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, ColumnCacheMap &column_cache, Executor *executor, const std::vector< InnerOuter > &inner_outer_pairs, const std::vector< InnerOuterStringOpInfos > &col_pairs_string_op_infos, const int device_count, const RegisteredQueryHint &query_hints, const HashTableBuildDagMap &hashtable_build_dag_map, const TableIdToNodeMap &table_id_to_node_map)

size_t	getComponentBufferSize () const noexceptoverride

size_t	getKeyBufferSize () const noexcept

virtual void	reifyWithLayout (const HashType layout)

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

virtual std::pair< size_t, size_t >	approximateTupleCount (const std::vector< ColumnsForDevice > &) const

virtual size_t	getKeyComponentWidth () const

virtual size_t	getKeyComponentCount () const

virtual llvm::Value *	codegenKey (const CompilationOptions &)

size_t	shardCount () const

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

void	reify (const HashType preferred_layout)

void	copyCpuHashTableToGpu (std::shared_ptr< BaselineHashTable > &cpu_hash_table, const int device_id, Data_Namespace::DataMgr *data_mgr)

virtual void	reifyForDevice (const ColumnsForDevice &columns_for_device, const HashType layout, const int device_id, const size_t entry_count, const size_t emitted_keys_count, const logger::ThreadLocalIds parent_thread_local_ids)

virtual int	initHashTableForDevice (const std::vector< JoinColumn > &join_columns, const std::vector< JoinColumnTypeInfo > &join_column_types, const std::vector< JoinBucketInfo > &join_buckets, const HashType layout, const Data_Namespace::MemoryLevel effective_memory_level, const size_t entry_count, const size_t emitted_keys_count, const int device_id)

llvm::Value *	hashPtr (const size_t index)

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

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

bool	isBitwiseEq () const override

ChunkKey	genChunkKey (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments) const

Static Protected Member Functions
static shared::TableKey	getInnerTableId (const std::vector< InnerOuter > &inner_outer_pairs)

static QueryPlanHash	getAlternativeCacheKey (AlternativeCacheKeyForBaselineHashJoin &info)

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
const std::shared_ptr < Analyzer::BinOper >	condition_

const JoinType	join_type_

const std::vector < InputTableInfo > &	query_infos_

const Data_Namespace::MemoryLevel	memory_level_

Executor *	executor_

ColumnCacheMap &	column_cache_

std::mutex	cpu_hash_table_buff_mutex_

std::mutex	str_proxy_translation_mutex_

std::vector< const StringDictionaryProxy::IdMap * >	str_proxy_translation_maps_

std::vector< InnerOuter >	inner_outer_pairs_

std::vector < InnerOuterStringOpInfos >	inner_outer_string_op_infos_pairs_

const int	device_count_

RegisteredQueryHint	query_hints_

bool	needs_dict_translation_

std::optional< HashType >	layout_override_

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_

Protected Attributes inherited from HashJoin
std::vector< std::shared_ptr < HashTable > >	hash_tables_for_device_

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

static std::unique_ptr < HashingSchemeRecycler >	hash_table_layout_cache_

Detailed Description

Definition at line 49 of file BaselineJoinHashTable.h.

Constructor & Destructor Documentation

virtual BaselineJoinHashTable::~BaselineJoinHashTable ( )

inlinevirtual

Definition at line 139 of file BaselineJoinHashTable.h.

139 {}

BaselineJoinHashTable::BaselineJoinHashTable	(	const std::shared_ptr< Analyzer::BinOper >	condition,
		const JoinType	join_type,
		const std::vector< InputTableInfo > &	query_infos,
		const Data_Namespace::MemoryLevel	memory_level,
		ColumnCacheMap &	column_cache,
		Executor *	executor,
		const std::vector< InnerOuter > &	inner_outer_pairs,
		const std::vector< InnerOuterStringOpInfos > &	col_pairs_string_op_infos,
		const int	device_count,
		const RegisteredQueryHint &	query_hints,
		const HashTableBuildDagMap &	hashtable_build_dag_map,
		const TableIdToNodeMap &	table_id_to_node_map
	)

protected

Definition at line 114 of file BaselineJoinHashTable.cpp.

References CHECK_GT, device_count_, and HashJoin::hash_tables_for_device_.

Referenced by getInstance().

     : condition_(condition)
     , join_type_(join_type)
     , query_infos_(query_infos)
     , memory_level_(memory_level)
     , executor_(executor)
     , column_cache_(column_cache)
     , inner_outer_pairs_(inner_outer_pairs)
     , inner_outer_string_op_infos_pairs_(col_pairs_string_op_infos)
     , 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) {
   CHECK_GT(device_count_, 0);
   hash_tables_for_device_.resize(std::max(device_count_, 1));
 }

Here is the caller graph for this function:

Member Function Documentation

std::pair< size_t, size_t > BaselineJoinHashTable::approximateTupleCount ( const std::vector< ColumnsForDevice > & columns_per_device ) const

protectedvirtual

Definition at line 516 of file BaselineJoinHashTable.cpp.

References approximate_distinct_tuples(), approximate_distinct_tuples_on_device(), threading_serial::async(), Bitmap, CHECK, CHECK_EQ, CPU, Data_Namespace::CPU_LEVEL, cpu_threads(), device_count_, executor_, getEffectiveMemoryLevel(), getQueryEngineCudaStreamForDevice(), GPU, Data_Namespace::GPU_LEVEL, hll_size(), hll_unify(), inner_outer_pairs_, transfer_flat_object_to_gpu(), transfer_vector_of_flat_objects_to_gpu(), and UNREACHABLE.

Referenced by reifyWithLayout().

                                                                  {
   const auto effective_memory_level = getEffectiveMemoryLevel(inner_outer_pairs_);
   CountDistinctDescriptor count_distinct_desc{
       CountDistinctImplType::Bitmap,
       0,
       11,
       true,
       effective_memory_level == Data_Namespace::MemoryLevel::GPU_LEVEL
           ? ExecutorDeviceType::GPU
           : ExecutorDeviceType::CPU,
       1};
   const auto padded_size_bytes = count_distinct_desc.bitmapPaddedSizeBytes();
 
   CHECK(!columns_per_device.empty() && !columns_per_device.front().join_columns.empty());
 
   if (effective_memory_level == Data_Namespace::MemoryLevel::CPU_LEVEL) {
     int thread_count = cpu_threads();
     std::vector<uint8_t> hll_buffer_all_cpus(thread_count * padded_size_bytes);
     auto hll_result = &hll_buffer_all_cpus[0];
 
     approximate_distinct_tuples(hll_result,
                                 count_distinct_desc.bitmap_sz_bits,
                                 padded_size_bytes,
                                 columns_per_device.front().join_columns,
                                 columns_per_device.front().join_column_types,
                                 thread_count);
     for (int i = 1; i < thread_count; ++i) {
       hll_unify(hll_result,
                 hll_result + i * padded_size_bytes,
                 1 << count_distinct_desc.bitmap_sz_bits);
     }
     return std::make_pair(hll_size(hll_result, count_distinct_desc.bitmap_sz_bits), 0);
   }
 #ifdef HAVE_CUDA
   auto data_mgr = executor_->getDataMgr();
   std::vector<std::vector<uint8_t>> host_hll_buffers(device_count_);
   for (auto& host_hll_buffer : host_hll_buffers) {
     host_hll_buffer.resize(count_distinct_desc.bitmapPaddedSizeBytes());
   }
   std::vector<std::future<void>> approximate_distinct_device_threads;
   for (int device_id = 0; device_id < device_count_; ++device_id) {
     approximate_distinct_device_threads.emplace_back(std::async(
         std::launch::async,
         [device_id,
          &columns_per_device,
          &count_distinct_desc,
          data_mgr,
          &host_hll_buffers] {
           auto allocator = std::make_unique<CudaAllocator>(
               data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
           auto device_hll_buffer =
               allocator->alloc(count_distinct_desc.bitmapPaddedSizeBytes());
           data_mgr->getCudaMgr()->zeroDeviceMem(
               device_hll_buffer,
               count_distinct_desc.bitmapPaddedSizeBytes(),
               device_id,
               getQueryEngineCudaStreamForDevice(device_id));
           const auto& columns_for_device = columns_per_device[device_id];
           auto join_columns_gpu = transfer_vector_of_flat_objects_to_gpu(
               columns_for_device.join_columns, *allocator);
           auto join_column_types_gpu = transfer_vector_of_flat_objects_to_gpu(
               columns_for_device.join_column_types, *allocator);
           const auto key_handler =
               GenericKeyHandler(columns_for_device.join_columns.size(),
                                 true,
                                 join_columns_gpu,
                                 join_column_types_gpu,
                                 nullptr,
                                 nullptr);
           const auto key_handler_gpu =
               transfer_flat_object_to_gpu(key_handler, *allocator);
           approximate_distinct_tuples_on_device(
               reinterpret_cast<uint8_t*>(device_hll_buffer),
               count_distinct_desc.bitmap_sz_bits,
               key_handler_gpu,
               columns_for_device.join_columns[0].num_elems);
 
           auto& host_hll_buffer = host_hll_buffers[device_id];
           allocator->copyFromDevice(&host_hll_buffer[0],
                                     device_hll_buffer,
                                     count_distinct_desc.bitmapPaddedSizeBytes());
         }));
   }
   for (auto& child : approximate_distinct_device_threads) {
     child.get();
   }
   CHECK_EQ(Data_Namespace::MemoryLevel::GPU_LEVEL, effective_memory_level);
   auto& result_hll_buffer = host_hll_buffers.front();
   auto hll_result = reinterpret_cast<int32_t*>(&result_hll_buffer[0]);
   for (int device_id = 1; device_id < device_count_; ++device_id) {
     auto& host_hll_buffer = host_hll_buffers[device_id];
     hll_unify(hll_result,
               reinterpret_cast<int32_t*>(&host_hll_buffer[0]),
               1 << count_distinct_desc.bitmap_sz_bits);
   }
   return std::make_pair(hll_size(hll_result, count_distinct_desc.bitmap_sz_bits), 0);
 #else
   UNREACHABLE();
   return {0, 0};
 #endif  // HAVE_CUDA
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * BaselineJoinHashTable::codegenKey ( const CompilationOptions & co )

protectedvirtual

Definition at line 1014 of file BaselineJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, HashJoin::codegenColOrStringOper(), executor_, get_int_type(), get_max_rte_scan_table(), getKeyComponentCount(), getKeyComponentWidth(), inner_outer_pairs_, inner_outer_string_op_infos_pairs_, LL_BUILDER, LL_CONTEXT, LL_INT, and self_join_not_covered_by_left_deep_tree().

Referenced by codegenMatchingSet(), and codegenSlot().

                                                                          {
   AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
   const auto key_component_width = getKeyComponentWidth();
   CHECK(key_component_width == 4 || key_component_width == 8);
   const auto key_size_lv = LL_INT(getKeyComponentCount() * key_component_width);
   llvm::Value* key_buff_lv{nullptr};
   switch (key_component_width) {
     case 4:
       key_buff_lv =
           LL_BUILDER.CreateAlloca(llvm::Type::getInt32Ty(LL_CONTEXT), key_size_lv);
       break;
     case 8:
       key_buff_lv =
           LL_BUILDER.CreateAlloca(llvm::Type::getInt64Ty(LL_CONTEXT), key_size_lv);
       break;
     default:
       CHECK(false);
   }
 
   CodeGenerator code_generator(executor_);
   for (size_t i = 0; i < getKeyComponentCount(); ++i) {
     const auto key_comp_dest_lv = LL_BUILDER.CreateGEP(
         key_buff_lv->getType()->getScalarType()->getPointerElementType(),
         key_buff_lv,
         LL_INT(i));
     const auto& inner_outer_pair = inner_outer_pairs_[i];
     const auto outer_col = inner_outer_pair.second;
     const auto key_col_var = dynamic_cast<const Analyzer::ColumnVar*>(outer_col);
     const auto val_col_var =
         dynamic_cast<const Analyzer::ColumnVar*>(inner_outer_pair.first);
     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.");
     }
     auto key_lv = HashJoin::codegenColOrStringOper(
         outer_col, inner_outer_string_op_infos_pairs_[i].second, code_generator, co);
     const auto key_lv_ext =
         LL_BUILDER.CreateSExt(key_lv, get_int_type(key_component_width * 8, LL_CONTEXT));
     LL_BUILDER.CreateStore(key_lv_ext, key_comp_dest_lv);
   }
   return key_buff_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Implements HashJoin.

Definition at line 932 of file BaselineJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, HashJoin::codegenHashTableLoad(), codegenKey(), HashJoin::codegenMatchingSet(), executor_, get_int_type(), getComponentBufferSize(), HashJoin::getHashTableForDevice(), getHashType(), getKeyComponentCount(), getKeyComponentWidth(), LL_BUILDER, LL_CONTEXT, LL_INT, offsetBufferOff(), OneToMany, and to_string().

                         {
   AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
   const auto hash_table = getHashTableForDevice(size_t(0));
   CHECK(hash_table);
   const auto key_component_width = getKeyComponentWidth();
   CHECK(key_component_width == 4 || key_component_width == 8);
   auto key_buff_lv = codegenKey(co);
   CHECK(getHashType() == HashType::OneToMany);
   auto hash_ptr = HashJoin::codegenHashTableLoad(index, executor_);
   const auto composite_dict_ptr_type =
       llvm::Type::getIntNPtrTy(LL_CONTEXT, key_component_width * 8);
   const auto composite_key_dict =
       hash_ptr->getType()->isPointerTy()
           ? LL_BUILDER.CreatePointerCast(hash_ptr, composite_dict_ptr_type)
           : LL_BUILDER.CreateIntToPtr(hash_ptr, composite_dict_ptr_type);
   const auto key_component_count = getKeyComponentCount();
   const auto key = executor_->cgen_state_->emitExternalCall(
       "get_composite_key_index_" + std::to_string(key_component_width * 8),
       get_int_type(64, LL_CONTEXT),
       {key_buff_lv,
        LL_INT(key_component_count),
        composite_key_dict,
        LL_INT(hash_table->getEntryCount())});
   auto one_to_many_ptr = hash_ptr;
   if (one_to_many_ptr->getType()->isPointerTy()) {
     one_to_many_ptr =
         LL_BUILDER.CreatePtrToInt(hash_ptr, llvm::Type::getInt64Ty(LL_CONTEXT));
   } else {
     CHECK(one_to_many_ptr->getType()->isIntegerTy(64));
   }
   const auto composite_key_dict_size = offsetBufferOff();
   one_to_many_ptr =
       LL_BUILDER.CreateAdd(one_to_many_ptr, LL_INT(composite_key_dict_size));
   return HashJoin::codegenMatchingSet(
       {one_to_many_ptr, key, LL_INT(int64_t(0)), LL_INT(hash_table->getEntryCount() - 1)},
       false,
       false,
       false,
       getComponentBufferSize(),
       executor_);
 }

Here is the call graph for this function:

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

overridevirtual

Implements HashJoin.

Definition at line 914 of file BaselineJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, CHECK, codegenKey(), executor_, get_int_type(), HashJoin::getHashTableForDevice(), getHashType(), getKeyComponentCount(), getKeyComponentWidth(), hashPtr(), LL_BUILDER, LL_CONTEXT, LL_INT, OneToOne, and to_string().

                                                                     {
   AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
   CHECK(getHashType() == HashType::OneToOne);
   const auto key_component_width = getKeyComponentWidth();
   CHECK(key_component_width == 4 || key_component_width == 8);
   auto key_buff_lv = codegenKey(co);
   const auto hash_ptr = hashPtr(index);
   const auto key_ptr_lv =
       LL_BUILDER.CreatePointerCast(key_buff_lv, llvm::Type::getInt8PtrTy(LL_CONTEXT));
   const auto key_size_lv = LL_INT(getKeyComponentCount() * key_component_width);
   const auto hash_table = getHashTableForDevice(size_t(0));
   return executor_->cgen_state_->emitExternalCall(
       "baseline_hash_join_idx_" + std::to_string(key_component_width * 8),
       get_int_type(64, LL_CONTEXT),
       {hash_ptr, key_ptr_lv, key_size_lv, LL_INT(hash_table->getEntryCount())});
 }

Here is the call graph for this function:

void BaselineJoinHashTable::copyCpuHashTableToGpu	(	std::shared_ptr< BaselineHashTable > &	cpu_hash_table,
		const int	device_id,
		Data_Namespace::DataMgr *	data_mgr
	)

protected

Definition at line 718 of file BaselineJoinHashTable.cpp.

References BaselineJoinHashTableBuilder::allocateDeviceMemory(), CHECK, CPU, executor_, BaselineJoinHashTableBuilder::getHashTable(), getKeyComponentCount(), getKeyComponentWidth(), getQueryEngineCudaStreamForDevice(), HashJoin::hash_tables_for_device_, and query_hints_.

Referenced by initHashTableForDevice(), and reifyWithLayout().

                                      {
   BaselineJoinHashTableBuilder builder;
 
   builder.allocateDeviceMemory(cpu_hash_table->getLayout(),
                                getKeyComponentWidth(),
                                getKeyComponentCount(),
                                cpu_hash_table->getEntryCount(),
                                cpu_hash_table->getEmittedKeysCount(),
                                device_id,
                                executor_,
                                query_hints_);
   auto gpu_target_hash_table = builder.getHashTable();
   CHECK(gpu_target_hash_table);
 
   const auto gpu_buff = gpu_target_hash_table->getGpuBuffer();
   CHECK(gpu_buff);
   auto allocator = std::make_unique<CudaAllocator>(
       data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
   allocator->copyToDevice(
       gpu_buff,
       cpu_hash_table->getCpuBuffer(),
       cpu_hash_table->getHashTableBufferSize(ExecutorDeviceType::CPU));
   hash_tables_for_device_[device_id] = std::move(gpu_target_hash_table);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t BaselineJoinHashTable::countBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 980 of file BaselineJoinHashTable.cpp.

References getComponentBufferSize(), getHashType(), getKeyBufferSize(), HashJoin::layoutRequiresAdditionalBuffers(), and offsetBufferOff().

Referenced by payloadBufferOff(), toSet(), and toString().

                                                             {
   if (layoutRequiresAdditionalBuffers(getHashType())) {
     return offsetBufferOff() + getComponentBufferSize();
   } else {
     return getKeyBufferSize();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protectedvirtual

Definition at line 619 of file BaselineJoinHashTable.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 reifyWithLayout().

                                      {
   const auto effective_memory_level =
       get_effective_memory_level(memory_level_, needs_dict_translation_);
 
   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;
   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 BaselineJoinHashTable::genChunkKey ( const std::vector< Fragmenter_Namespace::FragmentInfo > & fragments ) const

protected

Definition at line 1142 of file BaselineJoinHashTable.cpp.

Referenced by reifyWithLayout().

                                                                         {
   std::vector<int> fragment_ids;
   std::for_each(
       fragments.cbegin(), fragments.cend(), [&fragment_ids](const auto& fragment) {
         fragment_ids.push_back(fragment.fragmentId);
       });
   return fragment_ids;
 }

Here is the caller graph for this function:

static QueryPlanHash BaselineJoinHashTable::getAlternativeCacheKey ( AlternativeCacheKeyForBaselineHashJoin & info )

inlinestaticprotected

Definition at line 234 of file BaselineJoinHashTable.h.

References BaselineJoinHashTable::AlternativeCacheKeyForBaselineHashJoin::inner_outer_pairs, BaselineJoinHashTable::AlternativeCacheKeyForBaselineHashJoin::inner_outer_string_op_infos_pairs, BaselineJoinHashTable::AlternativeCacheKeyForBaselineHashJoin::join_type, BaselineJoinHashTable::AlternativeCacheKeyForBaselineHashJoin::num_elements, BaselineJoinHashTable::AlternativeCacheKeyForBaselineHashJoin::optype, and toString().

Referenced by reifyWithLayout().

                                                     {
     auto hash = boost::hash_value(::toString(info.optype));
     for (InnerOuter inner_outer : info.inner_outer_pairs) {
       auto inner_col = inner_outer.first;
       auto rhs_col_var = dynamic_cast<const Analyzer::ColumnVar*>(inner_outer.second);
       auto outer_col = rhs_col_var ? rhs_col_var : inner_col;
       boost::hash_combine(hash, inner_col->toString());
       if (inner_col->get_type_info().is_string()) {
         boost::hash_combine(hash, outer_col->toString());
       }
     }
     if (info.inner_outer_string_op_infos_pairs.size()) {
       boost::hash_combine(hash, ::toString(info.inner_outer_string_op_infos_pairs));
     }
     boost::hash_combine(hash, info.num_elements);
     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 BaselineJoinHashTable::getComponentBufferSize ( ) const

overrideprotectedvirtualnoexcept

Implements HashJoin.

Definition at line 1009 of file BaselineJoinHashTable.cpp.

References HashJoin::getHashTableForDevice().

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

                                                                     {
   const auto hash_table = getHashTableForDevice(size_t(0));
   return hash_table->getEntryCount() * sizeof(int32_t);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int BaselineJoinHashTable::getDeviceCount ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 92 of file BaselineJoinHashTable.h.

References device_count_.

92 { return device_count_; };

BaselineJoinHashTable::device_count_

const int device_count_

Definition: BaselineJoinHashTable.h:266

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

protected

Definition at line 708 of file BaselineJoinHashTable.cpp.

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

Referenced by approximateTupleCount(), and reifyWithLayout().

                                                           {
   if (needs_dictionary_translation(
           inner_outer_pairs, inner_outer_string_op_infos_pairs_, 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:

static HashingSchemeRecycler* BaselineJoinHashTable::getHashingSchemeCache ( )

inlinestatic

Definition at line 132 of file BaselineJoinHashTable.h.

References CHECK, and hash_table_layout_cache_.

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

std::string BaselineJoinHashTable::getHashJoinType ( ) const

inlinefinalvirtual

Implements HashJoin.

Definition at line 100 of file BaselineJoinHashTable.h.

100 { return "Baseline"; }

static HashtableRecycler* BaselineJoinHashTable::getHashTableCache ( )

inlinestatic

Definition at line 128 of file BaselineJoinHashTable.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:

HashType BaselineJoinHashTable::getHashType ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1094 of file BaselineJoinHashTable.cpp.

References CHECK, HashJoin::getHashTableForDevice(), and layout_override_.

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

                                                            {
   auto hash_table = getHashTableForDevice(size_t(0));
   CHECK(hash_table);
   if (layout_override_) {
     return *layout_override_;
   } else {
     return hash_table->getLayout();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

shared::TableKey BaselineJoinHashTable::getInnerTableId ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1079 of file BaselineJoinHashTable.cpp.

References CHECK, and inner_outer_pairs_.

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

                                                                      {
   try {
     return getInnerTableId(inner_outer_pairs_);
   } catch (...) {
     CHECK(false);
   }
   return {0, 0};
 }

Here is the caller graph for this function:

shared::TableKey BaselineJoinHashTable::getInnerTableId ( const std::vector< InnerOuter > & inner_outer_pairs )

staticprotected

Definition at line 1104 of file BaselineJoinHashTable.cpp.

References CHECK.

                                                     {
   CHECK(!inner_outer_pairs.empty());
   const auto first_inner_col = inner_outer_pairs.front().first;
   return first_inner_col->getTableKey();
 }

int BaselineJoinHashTable::getInnerTableRteIdx ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 1088 of file BaselineJoinHashTable.cpp.

References CHECK, and inner_outer_pairs_.

                                                               {
   CHECK(!inner_outer_pairs_.empty());
   const auto first_inner_col = inner_outer_pairs_.front().first;
   return first_inner_col->get_rte_idx();
 }

std::shared_ptr< BaselineJoinHashTable > BaselineJoinHashTable::getInstance	(	const std::shared_ptr< Analyzer::BinOper >	condition,
		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 41 of file BaselineJoinHashTable.cpp.

References BaselineJoinHashTable(), HashJoin::getHashTypeString(), HashJoin::normalizeColumnPairs(), VLOG, and VLOGGING.

Referenced by HashJoin::getInstance().

                                                   {
   decltype(std::chrono::steady_clock::now()) ts1, ts2;
 
   if (VLOGGING(1)) {
     VLOG(1) << "Building keyed hash table " << getHashTypeString(preferred_hash_type)
             << " for qual: " << condition->toString();
     ts1 = std::chrono::steady_clock::now();
   }
   auto inner_outer_pairs =
       HashJoin::normalizeColumnPairs(condition.get(), executor->getTemporaryTables());
   const auto& inner_outer_cols = inner_outer_pairs.first;
   const auto& col_pairs_string_op_infos = inner_outer_pairs.second;
   auto join_hash_table = std::shared_ptr<BaselineJoinHashTable>(
       new BaselineJoinHashTable(condition,
                                 join_type,
                                 query_infos,
                                 memory_level,
                                 column_cache,
                                 executor,
                                 inner_outer_cols,
                                 col_pairs_string_op_infos,
                                 device_count,
                                 query_hints,
                                 hashtable_build_dag_map,
                                 table_id_to_node_map));
   try {
     join_hash_table->reify(preferred_hash_type);
   } 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 keyed 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:

size_t BaselineJoinHashTable::getKeyBufferSize ( ) const

protectednoexcept

Definition at line 996 of file BaselineJoinHashTable.cpp.

References CHECK, HashJoin::getHashTableForDevice(), getKeyComponentCount(), getKeyComponentWidth(), and HashJoin::layoutRequiresAdditionalBuffers().

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

                                                               {
   const auto key_component_width = getKeyComponentWidth();
   CHECK(key_component_width == 4 || key_component_width == 8);
   const auto key_component_count = getKeyComponentCount();
   auto hash_table = getHashTableForDevice(size_t(0));
   CHECK(hash_table);
   if (layoutRequiresAdditionalBuffers(hash_table->getLayout())) {
     return hash_table->getEntryCount() * key_component_count * key_component_width;
   } else {
     return hash_table->getEntryCount() * (key_component_count + 1) * key_component_width;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t BaselineJoinHashTable::getKeyComponentCount ( ) const

protectedvirtual

Definition at line 704 of file BaselineJoinHashTable.cpp.

References inner_outer_pairs_.

Referenced by codegenKey(), codegenMatchingSet(), codegenSlot(), copyCpuHashTableToGpu(), getKeyBufferSize(), initHashTableForDevice(), toSet(), and toString().

                                                          {
   return inner_outer_pairs_.size();
 }

Here is the caller graph for this function:

size_t BaselineJoinHashTable::getKeyComponentWidth ( ) const

protectedvirtual

Definition at line 692 of file BaselineJoinHashTable.cpp.

References CHECK_EQ, and inner_outer_pairs_.

Referenced by codegenKey(), codegenMatchingSet(), codegenSlot(), copyCpuHashTableToGpu(), getKeyBufferSize(), initHashTableForDevice(), toSet(), and toString().

                                                          {
   for (const auto& inner_outer_pair : inner_outer_pairs_) {
     const auto inner_col = inner_outer_pair.first;
     const auto& inner_col_ti = inner_col->get_type_info();
     if (inner_col_ti.get_logical_size() > 4) {
       CHECK_EQ(8, inner_col_ti.get_logical_size());
       return 8;
     }
   }
   return 4;
 }

Here is the caller graph for this function:

Data_Namespace::MemoryLevel BaselineJoinHashTable::getMemoryLevel ( ) const

inlineoverridevirtualnoexcept

Implements HashJoin.

Definition at line 88 of file BaselineJoinHashTable.h.

References memory_level_.

                                                                      {
     return memory_level_;
   };

const RegisteredQueryHint& BaselineJoinHashTable::getRegisteredQueryHint ( )

inline

Definition at line 137 of file BaselineJoinHashTable.h.

References query_hints_.

137 { return query_hints_; }

BaselineJoinHashTable::query_hints_

RegisteredQueryHint query_hints_

Definition: BaselineJoinHashTable.h:267

size_t BaselineJoinHashTable::getShardCountForCondition	(	const Analyzer::BinOper *	condition,
		const Executor *	executor,
		const std::vector< InnerOuter > &	inner_outer_pairs
	)

static

Definition at line 144 of file BaselineJoinHashTable.cpp.

References get_shard_count().

Referenced by RangeJoinHashTable::getInstance(), reify(), shardCount(), OverlapsJoinHashTable::shardCount(), and Executor::skipFragmentPair().

                                                     {
   for (const auto& inner_outer_pair : inner_outer_pairs) {
     const auto pair_shard_count = get_shard_count(inner_outer_pair, executor);
     if (pair_shard_count) {
       return pair_shard_count;
     }
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * BaselineJoinHashTable::hashPtr ( const size_t index )

protected

Definition at line 1065 of file BaselineJoinHashTable.cpp.

References AUTOMATIC_IR_METADATA, HashJoin::codegenHashTableLoad(), executor_, LL_BUILDER, and LL_CONTEXT.

Referenced by codegenSlot().

                                                             {
   AUTOMATIC_IR_METADATA(executor_->cgen_state_.get());
   auto hash_ptr = HashJoin::codegenHashTableLoad(index, executor_);
   const auto pi8_type = llvm::Type::getInt8PtrTy(LL_CONTEXT);
   return hash_ptr->getType()->isPointerTy()
              ? LL_BUILDER.CreatePointerCast(hash_ptr, pi8_type)
              : LL_BUILDER.CreateIntToPtr(hash_ptr, pi8_type);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int BaselineJoinHashTable::initHashTableForDevice	(	const std::vector< JoinColumn > &	join_columns,
		const std::vector< JoinColumnTypeInfo > &	join_column_types,
		const std::vector< JoinBucketInfo > &	join_buckets,
		const HashType	layout,
		const Data_Namespace::MemoryLevel	effective_memory_level,
		const size_t	entry_count,
		const size_t	emitted_keys_count,
		const int	device_id
	)

protectedvirtual

Definition at line 769 of file BaselineJoinHashTable.cpp.

References BASELINE_HT, CHECK, CHECK_EQ, CHECK_LT, copyCpuHashTableToGpu(), DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, cpu_hash_table_buff_mutex_, Data_Namespace::CPU_LEVEL, DEBUG_TIMER, decomposeStrDictTranslationMaps(), executor_, HashJoin::getCompositeKeyInfo(), BaselineJoinHashTableBuilder::getHashTable(), getInnerTableId(), getKeyComponentCount(), getKeyComponentWidth(), getQueryEngineCudaStreamForDevice(), Data_Namespace::GPU_LEVEL, hash_table_layout_cache_, HashJoin::hash_tables_for_device_, hashtable_cache_key_, HT_HASHING_SCHEME, BaselineJoinHashTableBuilder::initHashTableOnCpu(), BaselineJoinHashTableBuilder::initHashTableOnGpu(), inner_outer_pairs_, inner_outer_string_op_infos_pairs_, HashtableRecycler::isSafeToCacheHashtable(), join_type_, memory_level_, needs_dict_translation_, putHashTableOnCpuToCache(), query_hints_, str_proxy_translation_maps_, table_id_to_node_map_, transfer_vector_of_flat_objects_to_gpu(), and UNREACHABLE.

Referenced by reifyForDevice().

                          {
   auto timer = DEBUG_TIMER(__func__);
   const auto key_component_count = getKeyComponentCount();
   int err = 0;
   decltype(std::chrono::steady_clock::now()) ts1, ts2;
   ts1 = std::chrono::steady_clock::now();
   auto allow_hashtable_recycling =
       HashtableRecycler::isSafeToCacheHashtable(table_id_to_node_map_,
                                                 needs_dict_translation_,
                                                 inner_outer_string_op_infos_pairs_,
                                                 getInnerTableId(inner_outer_pairs_));
   HashType hashtable_layout = layout;
   if (effective_memory_level == Data_Namespace::CPU_LEVEL) {
     std::lock_guard<std::mutex> cpu_hash_table_buff_lock(cpu_hash_table_buff_mutex_);
 
     const auto composite_key_info = HashJoin::getCompositeKeyInfo(
         inner_outer_pairs_, executor_, inner_outer_string_op_infos_pairs_);
 
     CHECK(!join_columns.empty());
 
     if (memory_level_ == Data_Namespace::MemoryLevel::CPU_LEVEL) {
       CHECK_EQ(device_id, 0);
     }
     CHECK_LT(static_cast<size_t>(device_id), hash_tables_for_device_.size());
     std::shared_ptr<HashTable> hash_table{nullptr};
     const auto str_proxy_translation_map_ptrs_and_offsets =
         decomposeStrDictTranslationMaps(str_proxy_translation_maps_);
     BaselineJoinHashTableBuilder builder;
 
     const auto key_handler =
         GenericKeyHandler(key_component_count,
                           true,
                           &join_columns[0],
                           &join_column_types[0],
                           &str_proxy_translation_map_ptrs_and_offsets.first[0],
                           &str_proxy_translation_map_ptrs_and_offsets.second[0]);
     err = builder.initHashTableOnCpu(&key_handler,
                                      composite_key_info,
                                      join_columns,
                                      join_column_types,
                                      join_bucket_info,
                                      str_proxy_translation_map_ptrs_and_offsets,
                                      entry_count,
                                      join_columns.front().num_elems,
                                      hashtable_layout,
                                      join_type_,
                                      getKeyComponentWidth(),
                                      getKeyComponentCount(),
                                      query_hints_);
     hash_tables_for_device_[device_id] = builder.getHashTable();
     ts2 = std::chrono::steady_clock::now();
     auto hashtable_build_time =
         std::chrono::duration_cast<std::chrono::milliseconds>(ts2 - ts1).count();
     if (!err && allow_hashtable_recycling && hash_tables_for_device_[device_id]) {
       // add ht-related items to cache iff we have a valid hashtable
       putHashTableOnCpuToCache(hashtable_cache_key_[device_id],
                                CacheItemType::BASELINE_HT,
                                hash_tables_for_device_[device_id],
                                DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                                hashtable_build_time);
 
       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,
           {});
     }
     // 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).
     // Don't transfer the buffer if there was an error since we'll bail anyway.
     if (memory_level_ == Data_Namespace::GPU_LEVEL && !err) {
 #ifdef HAVE_CUDA
       auto cpu_hash_table = std::dynamic_pointer_cast<BaselineHashTable>(
           hash_tables_for_device_[device_id]);
       copyCpuHashTableToGpu(cpu_hash_table, device_id, executor_->getDataMgr());
 #else
       CHECK(false);
 #endif
     }
   } else {
 #ifdef HAVE_CUDA
     BaselineJoinHashTableBuilder builder;
 
     auto data_mgr = executor_->getDataMgr();
     CudaAllocator allocator(
         data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
     auto join_column_types_gpu =
         transfer_vector_of_flat_objects_to_gpu(join_column_types, allocator);
     auto join_columns_gpu =
         transfer_vector_of_flat_objects_to_gpu(join_columns, allocator);
     const auto key_handler = GenericKeyHandler(key_component_count,
                                                true,
                                                join_columns_gpu,
                                                join_column_types_gpu,
                                                nullptr,
                                                nullptr);
 
     err = builder.initHashTableOnGpu(&key_handler,
                                      join_columns,
                                      hashtable_layout,
                                      join_type_,
                                      getKeyComponentWidth(),
                                      getKeyComponentCount(),
                                      entry_count,
                                      emitted_keys_count,
                                      device_id,
                                      executor_,
                                      query_hints_);
     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< HashTable > BaselineJoinHashTable::initHashTableOnCpuFromCache	(	QueryPlanHash	key,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)

protected

Definition at line 1111 of file BaselineJoinHashTable.cpp.

References CHECK, DEBUG_TIMER, hash_table_cache_, and VLOG.

Referenced by reifyWithLayout().

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

Here is the caller graph for this function:

static void BaselineJoinHashTable::invalidateCache ( )

inlinestatic

Definition at line 102 of file BaselineJoinHashTable.h.

References CHECK, hash_table_cache_, and hash_table_layout_cache_.

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

bool BaselineJoinHashTable::isBitwiseEq ( ) const

overrideprotectedvirtual

Implements HashJoin.

Definition at line 1138 of file BaselineJoinHashTable.cpp.

References condition_, and kBW_EQ.

Referenced by fetchColumnsForDevice().

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

Here is the caller graph for this function:

static void BaselineJoinHashTable::markCachedItemAsDirty ( size_t table_key )

inlinestatic

Definition at line 110 of file BaselineJoinHashTable.h.

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

                                                       {
     CHECK(hash_table_cache_);
     CHECK(hash_table_layout_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::BASELINE_HT,
                                                DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
     }
   }

size_t BaselineJoinHashTable::offsetBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 976 of file BaselineJoinHashTable.cpp.

References getKeyBufferSize().

Referenced by codegenMatchingSet(), countBufferOff(), toSet(), and toString().

                                                              {
   return getKeyBufferSize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t BaselineJoinHashTable::payloadBufferOff ( ) const

overridevirtualnoexcept

Implements HashJoin.

Definition at line 988 of file BaselineJoinHashTable.cpp.

References countBufferOff(), getComponentBufferSize(), getHashType(), getKeyBufferSize(), and HashJoin::layoutRequiresAdditionalBuffers().

Referenced by toSet(), and toString().

                                                               {
   if (layoutRequiresAdditionalBuffers(getHashType())) {
     return countBufferOff() + getComponentBufferSize();
   } else {
     return getKeyBufferSize();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1121 of file BaselineJoinHashTable.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 BaselineJoinHashTable::reify ( const HashType preferred_layout )

protected

Definition at line 248 of file BaselineJoinHashTable.cpp.

References CHECK_EQ, CHECK_LT, HashJoin::checkHashJoinReplicationConstraint(), condition_, DEBUG_TIMER, device_count_, executor_, HashJoin::freeHashBufferMemory(), HashJoin::getCompositeKeyInfo(), getInnerTableId(), getShardCountForCondition(), inner_outer_pairs_, inner_outer_string_op_infos_pairs_, ManyToMany, needs_dict_translation_, needs_dictionary_translation(), OneToMany, reifyWithLayout(), and VLOG.

                                                                  {
   auto timer = DEBUG_TIMER(__func__);
   CHECK_LT(0, device_count_);
   const auto composite_key_info = HashJoin::getCompositeKeyInfo(
       inner_outer_pairs_, executor_, inner_outer_string_op_infos_pairs_);
   needs_dict_translation_ = needs_dictionary_translation(
       inner_outer_pairs_, inner_outer_string_op_infos_pairs_, executor_);
 
   HashJoin::checkHashJoinReplicationConstraint(
       getInnerTableId(inner_outer_pairs_),
       BaselineJoinHashTable::getShardCountForCondition(
           condition_.get(), executor_, inner_outer_pairs_),
       executor_);
 
   auto layout = preferred_layout;
   if (condition_->is_overlaps_oper()) {
     CHECK_EQ(inner_outer_pairs_.size(), size_t(1));
 
     if (inner_outer_pairs_[0].second->get_type_info().is_array()) {
       layout = HashType::ManyToMany;
     } else {
       layout = HashType::OneToMany;
     }
     try {
       reifyWithLayout(layout);
       return;
     } catch (const std::exception& e) {
       VLOG(1) << "Caught exception while building overlaps baseline hash table: "
               << e.what();
       throw;
     }
   }
 
   // Automatically prefer One-To-Many layouts when string operations are involved as these
   // tend to be cardinality-reducing operations.
   // Todo(todd): Ostensibly only string ops on the rhs/inner expression cause rhs dups and
   // so we may be too conservative here, but validate
 
   for (const auto& inner_outer_string_op_infos : inner_outer_string_op_infos_pairs_) {
     if (inner_outer_string_op_infos.first.size() ||
         inner_outer_string_op_infos.second.size()) {
       layout = HashType::OneToMany;
       break;
     }
   }
 
   try {
     reifyWithLayout(layout);
   } catch (const std::exception& e) {
     VLOG(1) << "Caught exception while building baseline hash table: " << e.what();
     // In perfect hash we CHECK that the layout is not OnetoMany here, but for baseline
     // we are catching all exceptions, so should determine if that is safe first
     // before we would CHECK and not throw an exception here
     if (layout == HashType::OneToMany) {
       throw(e);
     }
     freeHashBufferMemory();
     reifyWithLayout(HashType::OneToMany);
   }
 }

Here is the call graph for this function:

void BaselineJoinHashTable::reifyForDevice	(	const ColumnsForDevice &	columns_for_device,
		const HashType	layout,
		const int	device_id,
		const size_t	entry_count,
		const size_t	emitted_keys_count,
		const logger::ThreadLocalIds	parent_thread_local_ids
	)

protectedvirtual

Definition at line 658 of file BaselineJoinHashTable.cpp.

References DEBUG_TIMER_NEW_THREAD, get_effective_memory_level(), initHashTableForDevice(), ColumnsForDevice::join_buckets, ColumnsForDevice::join_column_types, ColumnsForDevice::join_columns, memory_level_, needs_dict_translation_, logger::ThreadLocalIds::setNewThreadId(), logger::ThreadLocalIds::thread_id_, and to_string().

Referenced by reifyWithLayout().

                                                         {
   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_);
   const auto err = initHashTableForDevice(columns_for_device.join_columns,
                                           columns_for_device.join_column_types,
                                           columns_for_device.join_buckets,
                                           layout,
                                           effective_memory_level,
                                           entry_count,
                                           emitted_keys_count,
                                           device_id);
   if (err) {
     throw HashJoinFail(
         std::string("Unrecognized error when initializing baseline hash table (") +
         std::to_string(err) + std::string(")"));
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BaselineJoinHashTable::reifyWithLayout ( const HashType layout )

protectedvirtual

Definition at line 309 of file BaselineJoinHashTable.cpp.

References gpu_enabled::accumulate(), approximateTupleCount(), threading_serial::async(), BASELINE_HT, HashJoin::canAccessHashTable(), CHECK, CHECK_EQ, condition_, copyCpuHashTableToGpu(), DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, Data_Namespace::CPU_LEVEL, device_count_, executor_, fetchColumnsForDevice(), genChunkKey(), get_entries_per_device(), get_inner_query_info(), getAlternativeCacheKey(), DataRecyclerUtil::getAlternativeTableKeys(), HashJoin::getCompositeKeyInfo(), getEffectiveMemoryLevel(), HashtableRecycler::getHashtableAccessPathInfo(), getInnerTableId(), Fragmenter_Namespace::TableInfo::getNumTuplesUpperBound(), getQueryEngineCudaStreamForDevice(), Data_Namespace::GPU_LEVEL, hash_table_cache_, HashJoin::hash_tables_for_device_, hashtable_build_dag_map_, hashtable_cache_key_, hashtable_cache_meta_info_, InputTableInfo::info, initHashTableOnCpuFromCache(), inner_outer_pairs_, inner_outer_string_op_infos_pairs_, HashtableRecycler::isInvalidHashTableCacheKey(), HashtableRecycler::isSafeToCacheHashtable(), join_type_, memory_level_, needs_dict_translation_, HashJoin::normalizeColumnPairs(), OneToMany, only_shards_for_device(), query_infos_, reifyForDevice(), shardCount(), str_proxy_translation_maps_, str_proxy_translation_mutex_, shared::TableKey::table_id, table_id_to_node_map_, table_keys_, logger::thread_local_ids(), HashJoin::translateCompositeStrDictProxies(), and UNREACHABLE.

Referenced by reify().

                                                                  {
   const auto& query_info = get_inner_query_info(getInnerTableId(), query_infos_).info;
   if (query_info.fragments.empty()) {
     return;
   }
 
   const auto total_entries = 2 * query_info.getNumTuplesUpperBound();
   if (total_entries > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     throw TooManyHashEntries();
   }
 
   std::vector<std::unique_ptr<CudaAllocator>> dev_buff_owners;
   std::vector<std::vector<Fragmenter_Namespace::FragmentInfo>> fragments_per_device;
   std::vector<ColumnsForDevice> columns_per_device;
   const auto shard_count = shardCount();
   auto entries_per_device =
       get_entries_per_device(total_entries, shard_count, device_count_, memory_level_);
   auto data_mgr = executor_->getDataMgr();
   // cached hash table lookup logic is similar with perfect join hash table
   // first, prepare fragment lists per device
   std::vector<ChunkKey> chunk_key_per_device;
   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]);
     chunk_key_per_device.emplace_back(std::move(chunk_key));
   }
 
   // prepare per-device cache key
   auto inner_outer_pairs =
       HashJoin::normalizeColumnPairs(condition_.get(), executor_->getTemporaryTables());
   const auto& inner_outer_cols = inner_outer_pairs.first;
   const auto& col_pairs_string_op_infos = inner_outer_pairs.second;
   auto hashtable_access_path_info =
       HashtableRecycler::getHashtableAccessPathInfo(inner_outer_cols,
                                                     col_pairs_string_op_infos,
                                                     condition_->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;
 
   // 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
   if (table_keys_.empty()) {
     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-passioned 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),
                                               [](const auto& sum, const auto& fragment) {
                                                 return sum + fragment.getNumTuples();
                                               });
       AlternativeCacheKeyForBaselineHashJoin cache_key{inner_outer_pairs_,
                                                        inner_outer_string_op_infos_pairs_,
                                                        num_tuples,
                                                        condition_->get_optype(),
                                                        join_type_,
                                                        chunk_key_per_device[device_id]};
       hashtable_cache_key_[device_id] = getAlternativeCacheKey(cache_key);
     }
   }
 
   // register a mapping between cache key and input tables of the hash table
   const auto 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_);
                     });
     }
   }
 
   // now, let's try to check whether we have a cached hash table for this join qual
   const auto effective_memory_level = getEffectiveMemoryLevel(inner_outer_pairs_);
 
   // todo (yoonmin) : support dictionary proxy cache for join including string op(s)
   if (effective_memory_level == Data_Namespace::CPU_LEVEL) {
     std::unique_lock<std::mutex> str_proxy_translation_lock(str_proxy_translation_mutex_);
     if (str_proxy_translation_maps_.empty()) {
       const auto composite_key_info = HashJoin::getCompositeKeyInfo(
           inner_outer_pairs_, executor_, inner_outer_string_op_infos_pairs_);
       str_proxy_translation_maps_ = HashJoin::translateCompositeStrDictProxies(
           composite_key_info, inner_outer_string_op_infos_pairs_, executor_);
       CHECK_EQ(str_proxy_translation_maps_.size(), inner_outer_pairs_.size());
     }
   }
 
   auto allow_hashtable_recycling =
       HashtableRecycler::isSafeToCacheHashtable(table_id_to_node_map_,
                                                 needs_dict_translation_,
                                                 inner_outer_string_op_infos_pairs_,
                                                 getInnerTableId(inner_outer_pairs_));
   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::BASELINE_HT,
                                       DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
       if (hash_table) {
         hash_tables_for_device_[device_id] = hash_table;
       } 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
         auto data_mgr = executor_->getDataMgr();
         for (int device_id = 0; device_id < device_count_; ++device_id) {
           auto cpu_hash_table = std::dynamic_pointer_cast<BaselineHashTable>(
               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) {
     const auto columns_for_device =
         fetchColumnsForDevice(fragments_per_device[device_id],
                               device_id,
                               memory_level_ == Data_Namespace::MemoryLevel::GPU_LEVEL
                                   ? dev_buff_owners[device_id].get()
                                   : nullptr);
     columns_per_device.push_back(columns_for_device);
   }
 
   auto hashtable_layout_type = layout;
   size_t emitted_keys_count = 0;
   if (hashtable_layout_type == HashType::OneToMany) {
     CHECK(!columns_per_device.front().join_columns.empty());
     emitted_keys_count = columns_per_device.front().join_columns.front().num_elems;
     size_t tuple_count;
     std::tie(tuple_count, std::ignore) = approximateTupleCount(columns_per_device);
     const auto entry_count = 2 * std::max(tuple_count, size_t(1));
 
     // reset entries per device with one to many info
     entries_per_device =
         get_entries_per_device(entry_count, shard_count, device_count_, memory_level_);
   }
   std::vector<std::future<void>> init_threads;
   for (int device_id = 0; device_id < device_count_; ++device_id) {
     const auto fragments =
         shard_count
             ? only_shards_for_device(query_info.fragments, device_id, device_count_)
             : query_info.fragments;
     init_threads.push_back(std::async(std::launch::async,
                                       &BaselineJoinHashTable::reifyForDevice,
                                       this,
                                       columns_per_device[device_id],
                                       hashtable_layout_type,
                                       device_id,
                                       entries_per_device,
                                       emitted_keys_count,
                                       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:

Here is the caller graph for this function:

size_t BaselineJoinHashTable::shardCount ( ) const

protected

Definition at line 684 of file BaselineJoinHashTable.cpp.

References condition_, executor_, getShardCountForCondition(), Data_Namespace::GPU_LEVEL, inner_outer_pairs_, and memory_level_.

Referenced by reifyWithLayout().

                                                {
   if (memory_level_ != Data_Namespace::GPU_LEVEL) {
     return 0;
   }
   return BaselineJoinHashTable::getShardCountForCondition(
       condition_.get(), executor_, inner_outer_pairs_);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Implements HashJoin.

Definition at line 198 of file BaselineJoinHashTable.cpp.

References CHECK, countBufferOff(), executor_, HashJoin::getHashTableForDevice(), HashJoin::getJoinHashBuffer(), getKeyComponentCount(), getKeyComponentWidth(), getQueryEngineCudaStreamForDevice(), GPU, offsetBufferOff(), OneToOne, payloadBufferOff(), and HashTable::toSet().

                                {
   auto buffer = getJoinHashBuffer(device_type, device_id);
   auto hash_table = getHashTableForDevice(device_id);
   CHECK(hash_table);
   auto buffer_size = hash_table->getHashTableBufferSize(device_type);
 #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() : buffer;
 #else
   auto ptr1 = buffer;
 #endif  // HAVE_CUDA
   auto ptr2 = ptr1 + offsetBufferOff();
   auto ptr3 = ptr1 + countBufferOff();
   auto ptr4 = ptr1 + payloadBufferOff();
   const auto layout = hash_table->getLayout();
   return HashTable::toSet(getKeyComponentCount() + (layout == HashType::OneToOne ? 1 : 0),
                           getKeyComponentWidth(),
                           hash_table->getEntryCount(),
                           ptr1,
                           ptr2,
                           ptr3,
                           ptr4,
                           buffer_size);
 }

Here is the call graph for this function:

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

overridevirtual

Implements HashJoin.

Definition at line 157 of file BaselineJoinHashTable.cpp.

References CHECK, CHECK_LT, countBufferOff(), executor_, getHashType(), HashJoin::getHashTypeString(), HashJoin::getJoinHashBuffer(), getKeyComponentCount(), getKeyComponentWidth(), getQueryEngineCudaStreamForDevice(), GPU, HashJoin::hash_tables_for_device_, offsetBufferOff(), OneToOne, payloadBufferOff(), and HashTable::toString().

Referenced by getAlternativeCacheKey().

                                                             {
   auto buffer = getJoinHashBuffer(device_type, device_id);
   CHECK_LT(static_cast<size_t>(device_id), hash_tables_for_device_.size());
   auto hash_table = hash_tables_for_device_[device_id];
   CHECK(hash_table);
   auto buffer_size = hash_table->getHashTableBufferSize(device_type);
 #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() : buffer;
 #else
   auto ptr1 = buffer;
 #endif  // HAVE_CUDA
   auto ptr2 = ptr1 + offsetBufferOff();
   auto ptr3 = ptr1 + countBufferOff();
   auto ptr4 = ptr1 + payloadBufferOff();
   CHECK(hash_table);
   const auto layout = getHashType();
   return HashTable::toString(
       "keyed",
       getHashTypeString(layout),
       getKeyComponentCount() + (layout == HashType::OneToOne ? 1 : 0),
       getKeyComponentWidth(),
       hash_table->getEntryCount(),
       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

ColumnCacheMap& BaselineJoinHashTable::column_cache_

protected

Definition at line 259 of file BaselineJoinHashTable.h.

Referenced by fetchColumnsForDevice().

const std::shared_ptr<Analyzer::BinOper> BaselineJoinHashTable::condition_

protected

Definition at line 254 of file BaselineJoinHashTable.h.

Referenced by isBitwiseEq(), reify(), reifyWithLayout(), and shardCount().

std::mutex BaselineJoinHashTable::cpu_hash_table_buff_mutex_

protected

Definition at line 260 of file BaselineJoinHashTable.h.

Referenced by initHashTableForDevice().

const int BaselineJoinHashTable::device_count_

protected

Definition at line 266 of file BaselineJoinHashTable.h.

Referenced by approximateTupleCount(), BaselineJoinHashTable(), getDeviceCount(), reify(), and reifyWithLayout().

Executor* BaselineJoinHashTable::executor_

protected

Definition at line 258 of file BaselineJoinHashTable.h.

Referenced by approximateTupleCount(), codegenKey(), codegenMatchingSet(), codegenSlot(), copyCpuHashTableToGpu(), fetchColumnsForDevice(), getEffectiveMemoryLevel(), hashPtr(), initHashTableForDevice(), reify(), reifyWithLayout(), shardCount(), toSet(), and toString().

std::unique_ptr< HashtableRecycler > BaselineJoinHashTable::hash_table_cache_

staticprotected

Initial value:

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

Definition at line 279 of file BaselineJoinHashTable.h.

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

std::unique_ptr< HashingSchemeRecycler > BaselineJoinHashTable::hash_table_layout_cache_

staticprotected

Initial value:

=

std::make_unique<HashingSchemeRecycler>()

Definition at line 280 of file BaselineJoinHashTable.h.

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

HashTableBuildDagMap BaselineJoinHashTable::hashtable_build_dag_map_

protected

Definition at line 272 of file BaselineJoinHashTable.h.

Referenced by reifyWithLayout().

std::vector<QueryPlanHash> BaselineJoinHashTable::hashtable_cache_key_

protected

Definition at line 274 of file BaselineJoinHashTable.h.

Referenced by initHashTableForDevice(), and reifyWithLayout().

HashtableCacheMetaInfo BaselineJoinHashTable::hashtable_cache_meta_info_

protected

Definition at line 275 of file BaselineJoinHashTable.h.

Referenced by reifyWithLayout().

std::vector<InnerOuter> BaselineJoinHashTable::inner_outer_pairs_

protected

Definition at line 264 of file BaselineJoinHashTable.h.

Referenced by approximateTupleCount(), codegenKey(), fetchColumnsForDevice(), getInnerTableId(), getInnerTableRteIdx(), getKeyComponentCount(), getKeyComponentWidth(), initHashTableForDevice(), reify(), reifyWithLayout(), and shardCount().

std::vector<InnerOuterStringOpInfos> BaselineJoinHashTable::inner_outer_string_op_infos_pairs_

protected

Definition at line 265 of file BaselineJoinHashTable.h.

Referenced by codegenKey(), getEffectiveMemoryLevel(), initHashTableForDevice(), reify(), and reifyWithLayout().

const JoinType BaselineJoinHashTable::join_type_

protected

Definition at line 255 of file BaselineJoinHashTable.h.

Referenced by initHashTableForDevice(), and reifyWithLayout().

std::optional<HashType> BaselineJoinHashTable::layout_override_

protected

Definition at line 270 of file BaselineJoinHashTable.h.

Referenced by getHashType().

const Data_Namespace::MemoryLevel BaselineJoinHashTable::memory_level_

protected

Definition at line 257 of file BaselineJoinHashTable.h.

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

bool BaselineJoinHashTable::needs_dict_translation_

mutableprotected

Definition at line 268 of file BaselineJoinHashTable.h.

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

RegisteredQueryHint BaselineJoinHashTable::query_hints_

protected

Definition at line 267 of file BaselineJoinHashTable.h.

Referenced by copyCpuHashTableToGpu(), getRegisteredQueryHint(), and initHashTableForDevice().

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

protected

Definition at line 256 of file BaselineJoinHashTable.h.

Referenced by reifyWithLayout().

std::vector<const StringDictionaryProxy::IdMap*> BaselineJoinHashTable::str_proxy_translation_maps_

protected

Definition at line 262 of file BaselineJoinHashTable.h.

Referenced by initHashTableForDevice(), and reifyWithLayout().

std::mutex BaselineJoinHashTable::str_proxy_translation_mutex_

protected

Definition at line 261 of file BaselineJoinHashTable.h.

Referenced by reifyWithLayout().

const TableIdToNodeMap BaselineJoinHashTable::table_id_to_node_map_

protected

Definition at line 277 of file BaselineJoinHashTable.h.

Referenced by initHashTableForDevice(), and reifyWithLayout().

std::unordered_set<size_t> BaselineJoinHashTable::table_keys_

protected

Definition at line 276 of file BaselineJoinHashTable.h.

Referenced by reifyWithLayout().

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

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

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation