BaselineHashTableBuilder.h File Reference

#include "DataMgr/Allocators/CudaAllocator.h"
#include "QueryEngine/JoinHashTable/BaselineHashTable.h"
#include "QueryEngine/JoinHashTable/BaselineJoinHashTable.h"
#include "QueryEngine/JoinHashTable/Runtime/HashJoinKeyHandlers.h"
#include "QueryEngine/JoinHashTable/Runtime/JoinHashTableGpuUtils.h"
#include "QueryEngine/QueryEngine.h"
#include "Shared/thread_count.h"

Include dependency graph for BaselineHashTableBuilder.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	BaselineJoinHashTableBuilder

Functions
template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>
int	fill_baseline_hash_join_buff (int8_t *hash_buff, const size_t entry_count, const int32_t invalid_slot_val, const bool for_semi_join, const size_t key_component_count, const bool with_val_slot, const KEY_HANDLER *key_handler, const size_t num_elems, const int32_t cpu_thread_idx, const int32_t cpu_thread_count)
template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>
void	fill_baseline_hash_join_buff_on_device (int8_t *hash_buff, const size_t entry_count, const int32_t invalid_slot_val, const bool for_semi_join, const size_t key_component_count, const bool with_val_slot, int *dev_err_buff, const KEY_HANDLER *key_handler, const size_t num_elems)
template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>
void	fill_one_to_many_baseline_hash_table_on_device (int32_t *buff, const SIZE *composite_key_dict, const size_t hash_entry_count, const size_t key_component_count, const KEY_HANDLER *key_handler, const size_t num_elems, const bool for_window_framing)

Function Documentation

template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>

int fill_baseline_hash_join_buff	(	int8_t *	hash_buff,
		const size_t	entry_count,
		const int32_t	invalid_slot_val,
		const bool	for_semi_join,
		const size_t	key_component_count,
		const bool	with_val_slot,
		const KEY_HANDLER *	key_handler,
		const size_t	num_elems,
		const int32_t	cpu_thread_idx,
		const int32_t	cpu_thread_count
	)

Definition at line 30 of file BaselineHashTableBuilder.h.

References bbox_intersect_fill_baseline_hash_join_buff_32(), fill_baseline_hash_join_buff_32(), and range_fill_baseline_hash_join_buff_32().

Referenced by fill_baseline_hash_join_buff_wrapper().

                                                                 {
  if constexpr (std::is_same<KEY_HANDLER, GenericKeyHandler>::value) {
    return fill_baseline_hash_join_buff_32(hash_buff,
                                           entry_count,
                                           invalid_slot_val,
                                           for_semi_join,
                                           key_component_count,
                                           with_val_slot,
                                           key_handler,
                                           num_elems,
                                           cpu_thread_idx,
                                           cpu_thread_count);
  } else if constexpr (std::is_same<KEY_HANDLER, RangeKeyHandler>::value) {
    return range_fill_baseline_hash_join_buff_32(hash_buff,
                                                 entry_count,
                                                 invalid_slot_val,
                                                 key_component_count,
                                                 with_val_slot,
                                                 key_handler,
                                                 num_elems,
                                                 cpu_thread_idx,
                                                 cpu_thread_count);
  } else {
    static_assert(
        std::is_same<KEY_HANDLER, BoundingBoxIntersectKeyHandler>::value,
        "Only Generic, Bounding Box Intersect, and Range Key Handlers are supported.");
    return bbox_intersect_fill_baseline_hash_join_buff_32(hash_buff,
                                                          entry_count,
                                                          invalid_slot_val,
                                                          key_component_count,
                                                          with_val_slot,
                                                          key_handler,
                                                          num_elems,
                                                          cpu_thread_idx,
                                                          cpu_thread_count);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>

void fill_baseline_hash_join_buff_on_device	(	int8_t *	hash_buff,
		const size_t	entry_count,
		const int32_t	invalid_slot_val,
		const bool	for_semi_join,
		const size_t	key_component_count,
		const bool	with_val_slot,
		int *	dev_err_buff,
		const KEY_HANDLER *	key_handler,
		const size_t	num_elems
	)

Definition at line 130 of file BaselineHashTableBuilder.h.

References logger::FATAL, fill_baseline_hash_join_buff_on_device_32(), LOG, and UNREACHABLE.

                                                                    {
  if constexpr (std::is_same<KEY_HANDLER, GenericKeyHandler>::value) {
    fill_baseline_hash_join_buff_on_device_32(hash_buff,
                                              entry_count,
                                              invalid_slot_val,
                                              for_semi_join,
                                              key_component_count,
                                              with_val_slot,
                                              dev_err_buff,
                                              key_handler,
                                              num_elems);
  } else if constexpr (std::is_same<KEY_HANDLER, RangeKeyHandler>::value) {
    UNREACHABLE();
  } else {
    static_assert(
        std::is_same<KEY_HANDLER, BoundingBoxIntersectKeyHandler>::value,
        "Only Generic, Bounding Box Intersection, and Range Key Handlers are supported.");
    LOG(FATAL) << "32-bit keys not yet supported for bounding box intersect.";
  }
}

Here is the call graph for this function:

template<typename SIZE , class KEY_HANDLER , typename std::enable_if< sizeof(SIZE)==4, SIZE >::type * = nullptr>

void fill_one_to_many_baseline_hash_table_on_device	(	int32_t *	buff,
		const SIZE *	composite_key_dict,
		const size_t	hash_entry_count,
		const size_t	key_component_count,
		const KEY_HANDLER *	key_handler,
		const size_t	num_elems,
		const bool	for_window_framing
	)

Definition at line 208 of file BaselineHashTableBuilder.h.

References logger::FATAL, fill_one_to_many_baseline_hash_table_on_device_32(), and LOG.

                                                                                   {
  if constexpr (std::is_same<KEY_HANDLER, GenericKeyHandler>::value) {
    fill_one_to_many_baseline_hash_table_on_device_32(buff,
                                                      composite_key_dict,
                                                      hash_entry_count,
                                                      key_component_count,
                                                      key_handler,
                                                      num_elems,
                                                      for_window_framing);
  } else {
    static_assert(
        std::is_same<KEY_HANDLER, BoundingBoxIntersectKeyHandler>::value ||
            std::is_same<KEY_HANDLER, RangeKeyHandler>::value,
        "Only Generic, Bounding Box Intersection, and Range Key Handlers are supported.");
    LOG(FATAL) << "32-bit keys not yet supported for bounding box intersect.";
  }
}

Here is the call graph for this function: