#include <PerfectHashTableBuilder.h>

Public Member Functions
	PerfectJoinHashTableBuilder ()

void	allocateDeviceMemory (BucketizedHashEntryInfo hash_entry_info, PerfectHashTableEntryInfo hash_table_entry_info, const size_t shard_count, const int device_id, const int device_count, const Executor *executor)

void	initOneToOneHashTableOnCpu (const JoinColumn &join_column, const ExpressionRange &col_range, const bool is_bitwise_eq, const InnerOuter &cols, const StringDictionaryProxy::IdMap str_proxy_translation_map, const JoinType join_type, const BucketizedHashEntryInfo hash_entry_info, const PerfectHashTableEntryInfo hash_table_entry_info, const int32_t hash_join_invalid_val, const Executor executor)

void	initOneToManyHashTableOnCpu (const JoinColumn &join_column, const ExpressionRange &col_range, const bool is_bitwise_eq, const std::pair< const Analyzer::ColumnVar , const Analyzer::Expr > &cols, const StringDictionaryProxy::IdMap str_proxy_translation_map, const JoinType join_type, const BucketizedHashEntryInfo hash_entry_info, const PerfectHashTableEntryInfo hash_table_entry_info, const int32_t hash_join_invalid_val, const Executor executor)

std::unique_ptr< PerfectHashTable >	getHashTable ()

const bool	for_semi_anti_join (const JoinType join_type)

Static Public Member Functions
static size_t	get_entries_per_shard (const size_t total_entry_count, const size_t shard_count)

Private Attributes
std::unique_ptr< PerfectHashTable >	hash_table_

Detailed Description

Definition at line 25 of file PerfectHashTableBuilder.h.

Constructor & Destructor Documentation

PerfectJoinHashTableBuilder::PerfectJoinHashTableBuilder ( )

inline

Definition at line 27 of file PerfectHashTableBuilder.h.

27 {}

Member Function Documentation

void PerfectJoinHashTableBuilder::allocateDeviceMemory	(	BucketizedHashEntryInfo	hash_entry_info,
		PerfectHashTableEntryInfo	hash_table_entry_info,
		const size_t	shard_count,
		const int	device_id,
		const int	device_count,
		const Executor *	executor
	)

inline

Definition at line 29 of file PerfectHashTableBuilder.h.

References BucketizedHashEntryInfo::bucketized_hash_entry_count, CHECK, CHECK_GT, get_entries_per_shard(), BucketizedHashEntryInfo::getNormalizedHashEntryCount(), GPU, hash_table_, HashTableEntryInfo::setNumHashEntries(), UNREACHABLE, and VLOG.

Referenced by PerfectJoinHashTable::copyCpuHashTableToGpu(), and PerfectJoinHashTable::initHashTableForDevice().

                                                       {
 #ifdef HAVE_CUDA
     if (shard_count) {
       const auto shards_per_device = (shard_count + device_count - 1) / device_count;
       CHECK_GT(shards_per_device, 0u);
       const size_t entries_per_shard =
           get_entries_per_shard(hash_entry_info.bucketized_hash_entry_count, shard_count);
       hash_entry_info.bucketized_hash_entry_count = entries_per_shard * shards_per_device;
       hash_table_entry_info.setNumHashEntries(
           hash_entry_info.getNormalizedHashEntryCount());
     }
     CHECK(!hash_table_);
     hash_table_ = std::make_unique<PerfectHashTable>(ExecutorDeviceType::GPU,
                                                      hash_table_entry_info,
                                                      executor->getDataMgr(),
                                                      device_id);
     if (hash_table_entry_info.getNumKeys() == 0) {
       VLOG(1) << "Stop building a hash table based on a column: an input table is empty";
       return;
     }
     hash_table_->allocateGpuMemory(hash_table_entry_info.computeTotalNumSlots());
 #else
     UNREACHABLE();
 #endif  // HAVE_CUDA
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const bool PerfectJoinHashTableBuilder::for_semi_anti_join ( const JoinType join_type )

inline

Definition at line 373 of file PerfectHashTableBuilder.h.

References ANTI, and SEMI.

Referenced by initOneToOneHashTableOnCpu().

                                                           {
     return join_type == JoinType::SEMI || join_type == JoinType::ANTI;
   }

Here is the caller graph for this function:

static size_t PerfectJoinHashTableBuilder::get_entries_per_shard	(	const size_t	total_entry_count,
		const size_t	shard_count
	)

inlinestatic

Definition at line 367 of file PerfectHashTableBuilder.h.

References CHECK_NE.

Referenced by allocateDeviceMemory().

                                                                 {
     CHECK_NE(size_t(0), shard_count);
     return (total_entry_count + shard_count - 1) / shard_count;
   }

Here is the caller graph for this function:

std::unique_ptr<PerfectHashTable> PerfectJoinHashTableBuilder::getHashTable ( )

inline

Definition at line 363 of file PerfectHashTableBuilder.h.

References hash_table_.

Referenced by PerfectJoinHashTable::copyCpuHashTableToGpu(), and PerfectJoinHashTable::initHashTableForDevice().

                                                  {
     return std::move(hash_table_);
   }

Here is the caller graph for this function:

void PerfectJoinHashTableBuilder::initOneToManyHashTableOnCpu	(	const JoinColumn &	join_column,
		const ExpressionRange &	col_range,
		const bool	is_bitwise_eq,
		const std::pair< const Analyzer::ColumnVar , const Analyzer::Expr > &	cols,
		const StringDictionaryProxy::IdMap *	str_proxy_translation_map,
		const JoinType	join_type,
		const BucketizedHashEntryInfo	hash_entry_info,
		const PerfectHashTableEntryInfo	hash_table_entry_info,
		const int32_t	hash_join_invalid_val,
		const Executor *	executor
	)

inline

Definition at line 284 of file PerfectHashTableBuilder.h.

References run_benchmark_import::args, threading_serial::async(), CHECK, CPU, cpu_threads(), StringDictionaryProxy::TranslationMap< T >::data(), DEBUG_TIMER, StringDictionaryProxy::TranslationMap< T >::domainStart(), fill_one_to_many_hash_table(), fill_one_to_many_hash_table_bucketized(), get_join_column_type_kind(), ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), BucketizedHashEntryInfo::getNormalizedHashEntryCount(), HashTableEntryInfo::getNumKeys(), hash_table_, init_hash_join_buff(), inline_fixed_encoding_null_val(), kDATE, VLOG, and WINDOW_FUNCTION_FRAMING.

Referenced by PerfectJoinHashTable::initHashTableForDevice().

                                 {
     auto timer = DEBUG_TIMER(__func__);
     const auto inner_col = cols.first;
     CHECK(inner_col);
     const auto& ti = inner_col->get_type_info();
     CHECK(!hash_table_);
     hash_table_ = std::make_unique<PerfectHashTable>(ExecutorDeviceType::CPU,
                                                      hash_table_entry_info);
     if (hash_table_entry_info.getNumKeys() == 0) {
       VLOG(1) << "Stop building a hash table based on a column: an input table is empty";
       return;
     }
     auto cpu_hash_table_buff = reinterpret_cast<int32_t*>(hash_table_->getCpuBuffer());
     int thread_count = cpu_threads();
     {
       auto timer_init = DEBUG_TIMER("Initialize CPU One-To-Many Perfect Hash Table");
 #ifdef HAVE_TBB
       init_hash_join_buff_tbb(cpu_hash_table_buff,
                               hash_entry_info.getNormalizedHashEntryCount(),
                               hash_join_invalid_val);
 #else   // #ifdef HAVE_TBB
       std::vector<std::future<void>> init_threads;
       for (int thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
         init_threads.emplace_back(
             std::async(std::launch::async,
                        init_hash_join_buff,
                        cpu_hash_table_buff,
                        hash_entry_info.getNormalizedHashEntryCount(),
                        hash_join_invalid_val,
                        thread_idx,
                        thread_count));
       }
       for (auto& child : init_threads) {
         child.wait();
       }
       for (auto& child : init_threads) {
         child.get();
       }
 #endif  // !HAVE_TBB
     }
     auto timer_build = DEBUG_TIMER("Fill CPU One-To-Many Perfect Hash Table");
     auto const use_bucketization = inner_col->get_type_info().get_type() == kDATE;
     auto translated_null_val = col_range.getIntMax() + 1;
     if (col_range.getIntMax() < col_range.getIntMin()) {
       translated_null_val = col_range.getIntMin() - 1;
     }
     JoinColumnTypeInfo type_info{static_cast<size_t>(ti.get_size()),
                                  col_range.getIntMin(),
                                  col_range.getIntMax(),
                                  inline_fixed_encoding_null_val(ti),
                                  is_bitwise_eq,
                                  translated_null_val,
                                  get_join_column_type_kind(ti)};
     OneToManyPerfectJoinHashTableFillFuncArgs args{
         cpu_hash_table_buff,
         hash_entry_info,
         join_column,
         type_info,
         str_proxy_translation_map ? str_proxy_translation_map->data() : nullptr,
         str_proxy_translation_map ? str_proxy_translation_map->domainStart()
                                   : 0 /*dummy*/,
         hash_entry_info.bucket_normalization,
         join_type == JoinType::WINDOW_FUNCTION_FRAMING};
     decltype(&fill_one_to_many_hash_table) const hash_table_fill_func =
         use_bucketization ? fill_one_to_many_hash_table_bucketized
                           : fill_one_to_many_hash_table;
     hash_table_fill_func(args, thread_count);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void PerfectJoinHashTableBuilder::initOneToOneHashTableOnCpu	(	const JoinColumn &	join_column,
		const ExpressionRange &	col_range,
		const bool	is_bitwise_eq,
		const InnerOuter &	cols,
		const StringDictionaryProxy::IdMap *	str_proxy_translation_map,
		const JoinType	join_type,
		const BucketizedHashEntryInfo	hash_entry_info,
		const PerfectHashTableEntryInfo	hash_table_entry_info,
		const int32_t	hash_join_invalid_val,
		const Executor *	executor
	)

inline

Definition at line 186 of file PerfectHashTableBuilder.h.

References run_benchmark_import::args, threading_serial::async(), BucketizedHashEntryInfo::bucket_normalization, CHECK, CPU, cpu_threads(), StringDictionaryProxy::TranslationMap< T >::data(), DEBUG_TIMER, StringDictionaryProxy::TranslationMap< T >::domainStart(), fill_hash_join_buff(), fill_hash_join_buff_bitwise_eq(), fill_hash_join_buff_bucketized(), for_semi_anti_join(), get_join_column_type_kind(), ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), BucketizedHashEntryInfo::getNormalizedHashEntryCount(), HashTableEntryInfo::getNumKeys(), hash_table_, init_hash_join_buff(), inline_fixed_encoding_null_val(), kDATE, and VLOG.

Referenced by PerfectJoinHashTable::initHashTableForDevice().

                                 {
     auto timer = DEBUG_TIMER(__func__);
     const auto inner_col = cols.first;
     CHECK(inner_col);
     const auto& ti = inner_col->get_type_info();
     CHECK(!hash_table_);
     hash_table_ = std::make_unique<PerfectHashTable>(ExecutorDeviceType::CPU,
                                                      hash_table_entry_info);
     if (hash_table_entry_info.getNumKeys() == 0) {
       VLOG(1) << "Stop building a hash table based on a column: an input table is empty";
       return;
     }
     auto cpu_hash_table_buff = reinterpret_cast<int32_t*>(hash_table_->getCpuBuffer());
     const int thread_count = cpu_threads();
     {
       DEBUG_TIMER("Initialize CPU One-To-One Perfect Hash Table");
 #ifdef HAVE_TBB
       init_hash_join_buff_tbb(cpu_hash_table_buff,
                               hash_entry_info.getNormalizedHashEntryCount(),
                               hash_join_invalid_val);
 #else   // #ifdef HAVE_TBB
       std::vector<std::thread> init_cpu_buff_threads;
       for (int thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
         init_cpu_buff_threads.emplace_back([hash_entry_info,
                                             hash_join_invalid_val,
                                             thread_idx,
                                             thread_count,
                                             cpu_hash_table_buff] {
           init_hash_join_buff(cpu_hash_table_buff,
                               hash_entry_info.getNormalizedHashEntryCount(),
                               hash_join_invalid_val,
                               thread_idx,
                               thread_count);
         });
       }
       for (auto& t : init_cpu_buff_threads) {
         t.join();
       }
       init_cpu_buff_threads.clear();
 #endif  // !HAVE_TBB
     }
     auto const for_semi_join = for_semi_anti_join(join_type);
     auto const use_bucketization = inner_col->get_type_info().get_type() == kDATE;
     auto translated_null_val = col_range.getIntMax() + 1;
     if (col_range.getIntMax() < col_range.getIntMin()) {
       translated_null_val = col_range.getIntMin() - 1;
     }
     JoinColumnTypeInfo type_info{static_cast<size_t>(ti.get_size()),
                                  col_range.getIntMin(),
                                  col_range.getIntMax(),
                                  inline_fixed_encoding_null_val(ti),
                                  is_bitwise_eq,
                                  translated_null_val,
                                  get_join_column_type_kind(ti)};
     DEBUG_TIMER("Fill CPU One-To-One Perfect Hash Table");
     OneToOnePerfectJoinHashTableFillFuncArgs args{
         cpu_hash_table_buff,
         nullptr,
         hash_join_invalid_val,
         for_semi_join,
         join_column,
         type_info,
         str_proxy_translation_map ? str_proxy_translation_map->data() : nullptr,
         str_proxy_translation_map ? str_proxy_translation_map->domainStart()
                                   : 0,  // 0 is dummy value
         hash_entry_info.bucket_normalization};
     decltype(&fill_hash_join_buff) const hash_table_fill_func =
         use_bucketization      ? fill_hash_join_buff_bucketized
         : type_info.uses_bw_eq ? fill_hash_join_buff_bitwise_eq
                                : fill_hash_join_buff;
 
     std::vector<std::future<int>> fill_threads;
     for (int thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
       fill_threads.emplace_back(std::async(
           std::launch::async, hash_table_fill_func, args, thread_idx, thread_count));
     }
     for (auto& child : fill_threads) {
       child.wait();
     }
     for (auto& child : fill_threads) {
       if (child.get()) {  // see if task returns an error code
         // Too many hash entries, need to retry with a 1:many table
         hash_table_ = nullptr;  // clear the hash table buffer
         throw NeedsOneToManyHash();
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<PerfectHashTable> PerfectJoinHashTableBuilder::hash_table_

private

Definition at line 378 of file PerfectHashTableBuilder.h.

Referenced by allocateDeviceMemory(), getHashTable(), initOneToManyHashTableOnCpu(), and initOneToOneHashTableOnCpu().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/JoinHashTable/Builders/PerfectHashTableBuilder.h

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation