OmniSciDB  a5dc49c757
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Private Attributes | List of all members
BaselineJoinHashTableBuilder Class Reference

#include <BaselineHashTableBuilder.h>

Public Member Functions

 BaselineJoinHashTableBuilder ()=default
 
template<class KEY_HANDLER >
int initHashTableOnCpu (KEY_HANDLER *key_handler, const CompositeKeyInfo &composite_key_info, const std::vector< JoinColumn > &join_columns, const std::vector< JoinColumnTypeInfo > &join_column_types, const std::vector< JoinBucketInfo > &join_bucket_info, const StrProxyTranslationMapsPtrsAndOffsets &str_proxy_translation_maps_ptrs_and_offsets, const BaselineHashTableEntryInfo hash_table_entry_info, const JoinType join_type, const Executor *executor, const RegisteredQueryHint &query_hint)
 
void allocateDeviceMemory (const BaselineHashTableEntryInfo hash_table_entry_info, const int device_id, const Executor *executor, const RegisteredQueryHint &query_hint)
 
template<class KEY_HANDLER >
int initHashTableOnGpu (KEY_HANDLER *key_handler, const std::vector< JoinColumn > &join_columns, const JoinType join_type, const BaselineHashTableEntryInfo hash_table_entry_info, const int device_id, const Executor *executor, const RegisteredQueryHint &query_hint)
 
std::unique_ptr
< BaselineHashTable > 		getHashTable ()
 
void setHashLayout (HashType layout)
 
HashType getHashLayout () const
 

Private Attributes

std::unique_ptr
< BaselineHashTable > 		hash_table_
 
HashType layout_
 

Detailed Description

Definition at line 261 of file BaselineHashTableBuilder.h.

Constructor & Destructor Documentation

BaselineJoinHashTableBuilder::BaselineJoinHashTableBuilder ( )
default

Member Function Documentation

void BaselineJoinHashTableBuilder::allocateDeviceMemory ( const BaselineHashTableEntryInfo  hash_table_entry_info,
const int  device_id,
const Executor *  executor,
const RegisteredQueryHint &  query_hint 
)
inline

Definition at line 484 of file BaselineHashTableBuilder.h.

References BaselineHashTableEntryInfo::computeHashTableSize(), Data_Namespace::GPU_LEVEL, hash_table_, RegisteredQueryHint::isHintRegistered(), kMaxJoinHashTableSize, RegisteredQueryHint::max_join_hash_table_size, and UNREACHABLE.

Referenced by BaselineJoinHashTable::copyCpuHashTableToGpu(), and initHashTableOnGpu().

487  {
488 #ifdef HAVE_CUDA
489  const size_t hash_table_size = hash_table_entry_info.computeHashTableSize();
490  if (query_hint.isHintRegistered(QueryHint::kMaxJoinHashTableSize) &&
491  hash_table_size > query_hint.max_join_hash_table_size) {
492  throw JoinHashTableTooBig(hash_table_size, query_hint.max_join_hash_table_size);
493  }
494  if (hash_table_size > executor->maxGpuSlabSize()) {
495  throw JoinHashTableTooBig(hash_table_size, executor->maxGpuSlabSize());
496  }
497 
498  hash_table_ = std::make_unique<BaselineHashTable>(
499  MemoryLevel::GPU_LEVEL, hash_table_entry_info, executor->getDataMgr(), device_id);
500 #else
501  UNREACHABLE();
502 #endif
503  }
kMaxJoinHashTableSize
Definition: QueryHint.h:52
UNREACHABLE
#define UNREACHABLE()
Definition: Logger.h:338
BaselineJoinHashTableBuilder::hash_table_
std::unique_ptr< BaselineHashTable > hash_table_
Definition: BaselineHashTableBuilder.h:656
RegisteredQueryHint::max_join_hash_table_size
size_t max_join_hash_table_size
Definition: QueryHint.h:373
BaselineHashTableEntryInfo::computeHashTableSize
size_t computeHashTableSize() const override
Definition: BaselineHashTable.h:56
RegisteredQueryHint::isHintRegistered
bool isHintRegistered(const QueryHint hint) const
Definition: QueryHint.h:398
Data_Namespace::GPU_LEVEL
Definition: MemoryLevel.h:21

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

HashType BaselineJoinHashTableBuilder::getHashLayout ( ) const
inline

Definition at line 651 of file BaselineHashTableBuilder.h.

References layout_.

651  {
652  return layout_;
653  }
std::unique_ptr<BaselineHashTable> BaselineJoinHashTableBuilder::getHashTable ( )
inline

Definition at line 643 of file BaselineHashTableBuilder.h.

References hash_table_.

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

643  {
644  return std::move(hash_table_);
645  }
BaselineJoinHashTableBuilder::hash_table_
std::unique_ptr< BaselineHashTable > hash_table_
Definition: BaselineHashTableBuilder.h:656

+ Here is the caller graph for this function:

template<class KEY_HANDLER >
int BaselineJoinHashTableBuilder::initHashTableOnCpu ( KEY_HANDLER *  key_handler,
const CompositeKeyInfo &  composite_key_info,
const std::vector< JoinColumn > &  join_columns,
const std::vector< JoinColumnTypeInfo > &  join_column_types,
const std::vector< JoinBucketInfo > &  join_bucket_info,
const StrProxyTranslationMapsPtrsAndOffsets &  str_proxy_translation_maps_ptrs_and_offsets,
const BaselineHashTableEntryInfo  hash_table_entry_info,
const JoinType  join_type,
const Executor *  executor,
const RegisteredQueryHint &  query_hint 
)
inline

Definition at line 265 of file BaselineHashTableBuilder.h.

References ANTI, threading_serial::async(), CHECK, BaselineHashTableEntryInfo::computeHashTableSize(), Data_Namespace::CPU_LEVEL, cpu_threads(), DEBUG_TIMER, DEBUG_TIMER_NEW_THREAD, fill_one_to_many_baseline_hash_table_32(), fill_one_to_many_baseline_hash_table_64(), HashTableEntryInfo::getHashTableLayout(), hash_table_, init_baseline_hash_join_buff_32(), init_baseline_hash_join_buff_64(), init_hash_join_buff(), RegisteredQueryHint::isHintRegistered(), kMaxJoinHashTableSize, HashJoin::layoutRequiresAdditionalBuffers(), RegisteredQueryHint::max_join_hash_table_size, OneToOne, SEMI, setHashLayout(), logger::thread_local_ids(), UNREACHABLE, VLOG, and WINDOW_FUNCTION_FRAMING.

Referenced by BaselineJoinHashTable::initHashTableForDevice(), and BoundingBoxIntersectJoinHashTable::initHashTableOnCpu().

275  {
276  auto timer = DEBUG_TIMER(__func__);
277  auto const hash_table_layout = hash_table_entry_info.getHashTableLayout();
278  size_t const hash_table_size = hash_table_entry_info.computeHashTableSize();
279  if (query_hint.isHintRegistered(QueryHint::kMaxJoinHashTableSize) &&
280  hash_table_size > query_hint.max_join_hash_table_size) {
281  throw JoinHashTableTooBig(hash_table_size, query_hint.max_join_hash_table_size);
282  }
283  const bool for_semi_join =
284  (join_type == JoinType::SEMI || join_type == JoinType::ANTI) &&
285  hash_table_layout == HashType::OneToOne;
286  hash_table_ = std::make_unique<BaselineHashTable>(
287  MemoryLevel::CPU_LEVEL, hash_table_entry_info, nullptr, -1);
288  setHashLayout(hash_table_layout);
289  if (hash_table_entry_info.getNumKeys() == 0) {
290  VLOG(1) << "Stop building a hash table: the input table is empty";
291  return 0;
292  }
293  auto cpu_hash_table_ptr = hash_table_->getCpuBuffer();
294  int thread_count = cpu_threads();
295  std::vector<std::future<void>> init_cpu_buff_threads;
296  {
297  auto timer_init = DEBUG_TIMER("Initialize CPU Baseline Join Hash Table");
298 #ifdef HAVE_TBB
299  switch (hash_table_entry_info.getJoinKeysSize()) {
300  case 4:
301  init_baseline_hash_join_buff_tbb_32(cpu_hash_table_ptr,
302  hash_table_entry_info.getNumHashEntries(),
303  hash_table_entry_info.getNumJoinKeys(),
304  hash_table_layout == HashType::OneToOne,
305  -1);
306  break;
307  case 8:
308  init_baseline_hash_join_buff_tbb_64(cpu_hash_table_ptr,
309  hash_table_entry_info.getNumHashEntries(),
310  hash_table_entry_info.getNumJoinKeys(),
311  hash_table_layout == HashType::OneToOne,
312  -1);
313  break;
314  default:
315  CHECK(false);
316  }
317 #else // #ifdef HAVE_TBB
318  for (int thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
319  init_cpu_buff_threads.emplace_back(std::async(
320  std::launch::async,
321  [keyspace_entry_count,
322  key_component_count,
323  key_component_width,
324  thread_idx,
325  thread_count,
326  cpu_hash_table_ptr,
327  layout,
328  parent_thread_local_ids = logger::thread_local_ids()] {
329  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
330  DEBUG_TIMER_NEW_THREAD(parent_thread_local_ids.thread_id_);
331  switch (key_component_width) {
332  case 4:
333  init_baseline_hash_join_buff_32(cpu_hash_table_ptr,
334  keyspace_entry_count,
335  key_component_count,
336  layout == HashType::OneToOne,
337  -1,
338  thread_idx,
339  thread_count);
340  break;
341  case 8:
342  init_baseline_hash_join_buff_64(cpu_hash_table_ptr,
343  keyspace_entry_count,
344  key_component_count,
345  layout == HashType::OneToOne,
346  -1,
347  thread_idx,
348  thread_count);
349  break;
350  default:
351  UNREACHABLE();
352  }
353  }));
354  }
355  for (auto& child : init_cpu_buff_threads) {
356  child.get();
357  }
358 #endif // !HAVE_TBB
359  }
360  std::vector<std::future<int>> fill_cpu_buff_threads;
361  auto timer_fill = DEBUG_TIMER("Fill CPU Baseline Join Hash Table");
362  for (int thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
363  fill_cpu_buff_threads.emplace_back(std::async(
364  std::launch::async,
365  [key_handler,
366  &join_columns,
367  hash_table_entry_info,
368  thread_idx,
369  cpu_hash_table_ptr,
370  thread_count,
371  for_semi_join,
372  hash_table_layout,
373  parent_thread_local_ids = logger::thread_local_ids()] {
374  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
375  DEBUG_TIMER_NEW_THREAD(parent_thread_local_ids.thread_id_);
376  switch (hash_table_entry_info.getJoinKeysSize()) {
377  case 4: {
378  return fill_baseline_hash_join_buff<int32_t>(
379  cpu_hash_table_ptr,
380  hash_table_entry_info.getNumHashEntries(),
381  -1,
382  for_semi_join,
383  hash_table_entry_info.getNumJoinKeys(),
384  hash_table_layout == HashType::OneToOne,
385  key_handler,
386  join_columns[0].num_elems,
387  thread_idx,
388  thread_count);
389  }
390  case 8: {
391  return fill_baseline_hash_join_buff<int64_t>(
392  cpu_hash_table_ptr,
393  hash_table_entry_info.getNumHashEntries(),
394  -1,
395  for_semi_join,
396  hash_table_entry_info.getNumJoinKeys(),
397  hash_table_layout == HashType::OneToOne,
398  key_handler,
399  join_columns[0].num_elems,
400  thread_idx,
401  thread_count);
402  }
403  default:
404  UNREACHABLE() << "Unexpected hash join key size: "
405  << hash_table_entry_info.getJoinKeysSize();
406  }
407  return -1;
408  }));
409  }
410  int err = 0;
411  for (auto& child : fill_cpu_buff_threads) {
412  int partial_err = child.get();
413  if (partial_err) {
414  err = partial_err;
415  }
416  }
417  if (err) {
418  return err;
419  }
420  if (HashJoin::layoutRequiresAdditionalBuffers(hash_table_layout)) {
421  auto one_to_many_buff = reinterpret_cast<int32_t*>(
422  cpu_hash_table_ptr + hash_table_entry_info.getNumHashEntries() *
423  hash_table_entry_info.computeKeySize());
424  {
425  auto timer_init_additional_buffers =
426  DEBUG_TIMER("Initialize Additional Buffers for CPU Baseline Join Hash Table");
427  init_hash_join_buff(
428  one_to_many_buff, hash_table_entry_info.getNumHashEntries(), -1, 0, 1);
429  }
430  bool is_geo_compressed = false;
431  if constexpr (std::is_same_v<KEY_HANDLER, RangeKeyHandler>) {
432  if (const auto range_handler =
433  reinterpret_cast<const RangeKeyHandler*>(key_handler)) {
434  is_geo_compressed = range_handler->is_compressed_;
435  }
436  }
437  auto timer_fill_additional_buffers =
438  DEBUG_TIMER("Fill Additional Buffers for CPU Baseline Join Hash Table");
439  setHashLayout(hash_table_layout);
440  switch (hash_table_entry_info.getJoinKeysSize()) {
441  case 4: {
442  const auto composite_key_dict = reinterpret_cast<int32_t*>(cpu_hash_table_ptr);
443  fill_one_to_many_baseline_hash_table_32(
444  one_to_many_buff,
445  composite_key_dict,
446  hash_table_entry_info.getNumHashEntries(),
447  hash_table_entry_info.getNumJoinKeys(),
448  join_columns,
449  join_column_types,
450  join_bucket_info,
451  str_proxy_translation_maps_ptrs_and_offsets.first,
452  str_proxy_translation_maps_ptrs_and_offsets.second,
453  thread_count,
454  std::is_same_v<KEY_HANDLER, RangeKeyHandler>,
455  is_geo_compressed,
456  join_type == JoinType::WINDOW_FUNCTION_FRAMING);
457  break;
458  }
459  case 8: {
460  const auto composite_key_dict = reinterpret_cast<int64_t*>(cpu_hash_table_ptr);
461  fill_one_to_many_baseline_hash_table_64(
462  one_to_many_buff,
463  composite_key_dict,
464  hash_table_entry_info.getNumHashEntries(),
465  hash_table_entry_info.getNumJoinKeys(),
466  join_columns,
467  join_column_types,
468  join_bucket_info,
469  str_proxy_translation_maps_ptrs_and_offsets.first,
470  str_proxy_translation_maps_ptrs_and_offsets.second,
471  thread_count,
472  std::is_same_v<KEY_HANDLER, RangeKeyHandler>,
473  is_geo_compressed,
474  join_type == JoinType::WINDOW_FUNCTION_FRAMING);
475  break;
476  }
477  default:
478  CHECK(false);
479  }
480  }
481  return 0;
482  }
HashType::OneToOne
init_baseline_hash_join_buff_32
void init_baseline_hash_join_buff_32(int8_t *hash_join_buff, const int64_t entry_count, const size_t key_component_count, const bool with_val_slot, const int32_t invalid_slot_val, const int32_t cpu_thread_idx, const int32_t cpu_thread_count)
Definition: HashJoinRuntime.cpp:1788
fill_one_to_many_baseline_hash_table_64
void fill_one_to_many_baseline_hash_table_64(int32_t *buff, const int64_t *composite_key_dict, const int64_t hash_entry_count, const size_t key_component_count, const std::vector< JoinColumn > &join_column_per_key, const std::vector< JoinColumnTypeInfo > &type_info_per_key, const std::vector< JoinBucketInfo > &join_bucket_info, const std::vector< const int32_t * > &sd_inner_to_outer_translation_maps, const std::vector< int32_t > &sd_min_inner_elems, const int32_t cpu_thread_count, const bool is_range_join, const bool is_geo_compressed, const bool for_window_framing)
Definition: HashJoinRuntime.cpp:2218
kMaxJoinHashTableSize
Definition: QueryHint.h:52
fill_one_to_many_baseline_hash_table_32
void fill_one_to_many_baseline_hash_table_32(int32_t *buff, const int32_t *composite_key_dict, const int64_t hash_entry_count, const size_t key_component_count, const std::vector< JoinColumn > &join_column_per_key, const std::vector< JoinColumnTypeInfo > &type_info_per_key, const std::vector< JoinBucketInfo > &join_bucket_info, const std::vector< const int32_t * > &sd_inner_to_outer_translation_maps, const std::vector< int32_t > &sd_min_inner_elems, const int32_t cpu_thread_count, const bool is_range_join, const bool is_geo_compressed, const bool for_window_framing)
Definition: HashJoinRuntime.cpp:2189
UNREACHABLE
#define UNREACHABLE()
Definition: Logger.h:338
DEBUG_TIMER_NEW_THREAD
#define DEBUG_TIMER_NEW_THREAD(parent_thread_id)
Definition: Logger.h:417
init_baseline_hash_join_buff_64
void init_baseline_hash_join_buff_64(int8_t *hash_join_buff, const int64_t entry_count, const size_t key_component_count, const bool with_val_slot, const int32_t invalid_slot_val, const int32_t cpu_thread_idx, const int32_t cpu_thread_count)
Definition: HashJoinRuntime.cpp:1804
BaselineJoinHashTableBuilder::hash_table_
std::unique_ptr< BaselineHashTable > hash_table_
Definition: BaselineHashTableBuilder.h:656
Data_Namespace::CPU_LEVEL
Definition: MemoryLevel.h:21
RegisteredQueryHint::max_join_hash_table_size
size_t max_join_hash_table_size
Definition: QueryHint.h:373
BaselineHashTableEntryInfo::computeHashTableSize
size_t computeHashTableSize() const override
Definition: BaselineHashTable.h:56
threading_serial::async
future< Result > async(Fn &&fn, Args &&...args)
Definition: threading_serial.h:11
HashTableEntryInfo::getHashTableLayout
HashType getHashTableLayout() const
Definition: HashTable.h:53
RegisteredQueryHint::isHintRegistered
bool isHintRegistered(const QueryHint hint) const
Definition: QueryHint.h:398
init_hash_join_buff
DEVICE void SUFFIX() init_hash_join_buff(int32_t *groups_buffer, const int64_t hash_entry_count, const int32_t invalid_slot_val, const int32_t cpu_thread_idx, const int32_t cpu_thread_count)
Definition: HashJoinRuntime.cpp:71
CHECK
#define CHECK(condition)
Definition: Logger.h:291
DEBUG_TIMER
#define DEBUG_TIMER(name)
Definition: Logger.h:412
cpu_threads
int cpu_threads()
Definition: thread_count.h:25
logger::thread_local_ids
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:882
VLOG
#define VLOG(n)
Definition: Logger.h:388
HashJoin::layoutRequiresAdditionalBuffers
static bool layoutRequiresAdditionalBuffers(HashType layout) noexcept
Definition: HashJoin.h:176

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class KEY_HANDLER >
int BaselineJoinHashTableBuilder::initHashTableOnGpu ( KEY_HANDLER *  key_handler,
const std::vector< JoinColumn > &  join_columns,
const JoinType  join_type,
const BaselineHashTableEntryInfo  hash_table_entry_info,
const int  device_id,
const Executor *  executor,
const RegisteredQueryHint &  query_hint 
)
inline

Definition at line 506 of file BaselineHashTableBuilder.h.

References allocateDeviceMemory(), ANTI, CHECK, BaselineHashTableEntryInfo::computeKeySize(), DEBUG_TIMER, HashTableEntryInfo::getHashTableLayout(), BaselineHashTableEntryInfo::getJoinKeysSize(), HashTableEntryInfo::getNumHashEntries(), BaselineHashTableEntryInfo::getNumJoinKeys(), HashTableEntryInfo::getNumKeys(), getQueryEngineCudaStreamForDevice(), hash_table_, init_baseline_hash_join_buff_on_device_32(), init_baseline_hash_join_buff_on_device_64(), init_hash_join_buff_on_device(), HashJoin::layoutRequiresAdditionalBuffers(), OneToOne, SEMI, setHashLayout(), transfer_flat_object_to_gpu(), UNREACHABLE, VLOG, and WINDOW_FUNCTION_FRAMING.

Referenced by BaselineJoinHashTable::initHashTableForDevice().

512  {
513  auto timer = DEBUG_TIMER(__func__);
514  int err = 0;
515 #ifdef HAVE_CUDA
516  allocateDeviceMemory(hash_table_entry_info, device_id, executor, query_hint);
517  auto const hash_table_layout = hash_table_entry_info.getHashTableLayout();
518  setHashLayout(hash_table_layout);
519  if (hash_table_entry_info.getNumKeys() == 0) {
520  VLOG(1) << "Stop building a hash table based on a column: an input table is empty";
521  return 0;
522  }
523  auto data_mgr = executor->getDataMgr();
524  auto allocator = std::make_unique<CudaAllocator>(
525  data_mgr, device_id, getQueryEngineCudaStreamForDevice(device_id));
526  auto dev_err_buff = allocator->alloc(sizeof(int));
527  allocator->copyToDevice(dev_err_buff, &err, sizeof(err));
528  auto gpu_hash_table_buff = hash_table_->getGpuBuffer();
529  CHECK(gpu_hash_table_buff);
530  const bool for_semi_join =
531  (join_type == JoinType::SEMI || join_type == JoinType::ANTI) &&
532  hash_table_layout == HashType::OneToOne;
533  const auto key_handler_gpu = transfer_flat_object_to_gpu(*key_handler, *allocator);
534  {
535  auto timer_init = DEBUG_TIMER("Initialize GPU Baseline Join Hash Table");
536  switch (hash_table_entry_info.getJoinKeysSize()) {
537  case 4:
538  init_baseline_hash_join_buff_on_device_32(
539  gpu_hash_table_buff,
540  hash_table_entry_info.getNumHashEntries(),
541  hash_table_entry_info.getNumJoinKeys(),
542  hash_table_layout == HashType::OneToOne,
543  -1);
544  break;
545  case 8:
546  init_baseline_hash_join_buff_on_device_64(
547  gpu_hash_table_buff,
548  hash_table_entry_info.getNumHashEntries(),
549  hash_table_entry_info.getNumJoinKeys(),
550  hash_table_layout == HashType::OneToOne,
551  -1);
552  break;
553  default:
554  UNREACHABLE();
555  }
556  }
557  auto timer_fill = DEBUG_TIMER("Fill GPU Baseline Join Hash Table");
558  switch (hash_table_entry_info.getJoinKeysSize()) {
559  case 4: {
560  fill_baseline_hash_join_buff_on_device<int32_t>(
561  gpu_hash_table_buff,
562  hash_table_entry_info.getNumHashEntries(),
563  -1,
564  for_semi_join,
565  hash_table_entry_info.getNumJoinKeys(),
566  hash_table_layout == HashType::OneToOne,
567  reinterpret_cast<int*>(dev_err_buff),
568  key_handler_gpu,
569  join_columns.front().num_elems);
570  allocator->copyFromDevice(&err, dev_err_buff, sizeof(err));
571  break;
572  }
573  case 8: {
574  fill_baseline_hash_join_buff_on_device<int64_t>(
575  gpu_hash_table_buff,
576  hash_table_entry_info.getNumHashEntries(),
577  -1,
578  for_semi_join,
579  hash_table_entry_info.getNumJoinKeys(),
580  hash_table_layout == HashType::OneToOne,
581  reinterpret_cast<int*>(dev_err_buff),
582  key_handler_gpu,
583  join_columns.front().num_elems);
584  allocator->copyFromDevice(&err, dev_err_buff, sizeof(err));
585  break;
586  }
587  default:
588  UNREACHABLE();
589  }
590  if (err) {
591  return err;
592  }
593  if (HashJoin::layoutRequiresAdditionalBuffers(hash_table_layout)) {
594  auto one_to_many_buff = reinterpret_cast<int32_t*>(
595  gpu_hash_table_buff + hash_table_entry_info.getNumHashEntries() *
596  hash_table_entry_info.computeKeySize());
597  {
598  auto timer_init_additional_buf =
599  DEBUG_TIMER("Initialize Additional Buffer for GPU Baseline Join Hash Table");
600  init_hash_join_buff_on_device(
601  one_to_many_buff, hash_table_entry_info.getNumHashEntries(), -1);
602  }
603  setHashLayout(hash_table_layout);
604  auto timer_fill_additional_buf =
605  DEBUG_TIMER("Fill Additional Buffer for GPU Baseline Join Hash Table");
606  switch (hash_table_entry_info.getJoinKeysSize()) {
607  case 4: {
608  const auto composite_key_dict = reinterpret_cast<int32_t*>(gpu_hash_table_buff);
609  fill_one_to_many_baseline_hash_table_on_device<int32_t>(
610  one_to_many_buff,
611  composite_key_dict,
612  hash_table_entry_info.getNumHashEntries(),
613  hash_table_entry_info.getNumJoinKeys(),
614  key_handler_gpu,
615  join_columns.front().num_elems,
616  join_type == JoinType::WINDOW_FUNCTION_FRAMING);
617 
618  break;
619  }
620  case 8: {
621  const auto composite_key_dict = reinterpret_cast<int64_t*>(gpu_hash_table_buff);
622  fill_one_to_many_baseline_hash_table_on_device<int64_t>(
623  one_to_many_buff,
624  composite_key_dict,
625  hash_table_entry_info.getNumHashEntries(),
626  hash_table_entry_info.getNumJoinKeys(),
627  key_handler_gpu,
628  join_columns.front().num_elems,
629  join_type == JoinType::WINDOW_FUNCTION_FRAMING);
630 
631  break;
632  }
633  default:
634  UNREACHABLE();
635  }
636  }
637 #else
638  UNREACHABLE();
639 #endif
640  return err;
641  }
HashType::OneToOne
BaselineHashTableEntryInfo::computeKeySize
size_t computeKeySize() const
Definition: BaselineHashTable.h:45
transfer_flat_object_to_gpu
T * transfer_flat_object_to_gpu(const T &object, DeviceAllocator &allocator)
Definition: JoinHashTableGpuUtils.h:35
init_baseline_hash_join_buff_on_device_64
void init_baseline_hash_join_buff_on_device_64(int8_t *hash_join_buff, const int64_t entry_count, const size_t key_component_count, const bool with_val_slot, const int32_t invalid_slot_val)
Definition: HashJoinRuntimeGpu.cu:326
UNREACHABLE
#define UNREACHABLE()
Definition: Logger.h:338
BaselineJoinHashTableBuilder::hash_table_
std::unique_ptr< BaselineHashTable > hash_table_
Definition: BaselineHashTableBuilder.h:656
BaselineJoinHashTableBuilder::allocateDeviceMemory
void allocateDeviceMemory(const BaselineHashTableEntryInfo hash_table_entry_info, const int device_id, const Executor *executor, const RegisteredQueryHint &query_hint)
Definition: BaselineHashTableBuilder.h:484
init_baseline_hash_join_buff_on_device_32
void init_baseline_hash_join_buff_on_device_32(int8_t *hash_join_buff, const int64_t entry_count, const size_t key_component_count, const bool with_val_slot, const int32_t invalid_slot_val)
Definition: HashJoinRuntimeGpu.cu:313
HashTableEntryInfo::getHashTableLayout
HashType getHashTableLayout() const
Definition: HashTable.h:53
HashTableEntryInfo::getNumHashEntries
size_t getNumHashEntries() const
Definition: HashTable.h:50
init_hash_join_buff_on_device
void init_hash_join_buff_on_device(int32_t *buff, const int64_t entry_count, const int32_t invalid_slot_val)
Definition: HashJoinRuntimeGpu.cu:114
HashTableEntryInfo::getNumKeys
size_t getNumKeys() const
Definition: HashTable.h:51
getQueryEngineCudaStreamForDevice
CUstream getQueryEngineCudaStreamForDevice(int device_num)
Definition: QueryEngine.cpp:7
CHECK
#define CHECK(condition)
Definition: Logger.h:291
DEBUG_TIMER
#define DEBUG_TIMER(name)
Definition: Logger.h:412
BaselineHashTableEntryInfo::getNumJoinKeys
size_t getNumJoinKeys() const
Definition: BaselineHashTable.h:61
BaselineHashTableEntryInfo::getJoinKeysSize
size_t getJoinKeysSize() const
Definition: BaselineHashTable.h:63
VLOG
#define VLOG(n)
Definition: Logger.h:388
HashJoin::layoutRequiresAdditionalBuffers
static bool layoutRequiresAdditionalBuffers(HashType layout) noexcept
Definition: HashJoin.h:176

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void BaselineJoinHashTableBuilder::setHashLayout ( HashType  layout)
inline

Definition at line 647 of file BaselineHashTableBuilder.h.

References layout_.

Referenced by initHashTableOnCpu(), and initHashTableOnGpu().

647  {
648  layout_ = layout;
649  }

+ Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<BaselineHashTable> BaselineJoinHashTableBuilder::hash_table_
private

Definition at line 656 of file BaselineHashTableBuilder.h.

Referenced by allocateDeviceMemory(), getHashTable(), initHashTableOnCpu(), and initHashTableOnGpu().

HashType BaselineJoinHashTableBuilder::layout_
private

Definition at line 657 of file BaselineHashTableBuilder.h.

Referenced by getHashLayout(), and setHashLayout().

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