OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
QueryMemoryDescriptor Class Reference

#include <QueryMemoryDescriptor.h>

+ Collaboration diagram for QueryMemoryDescriptor:

Public Member Functions

 QueryMemoryDescriptor ()
 
 QueryMemoryDescriptor (const Executor *executor, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const bool allow_multifrag, const bool keyless_hash, const bool interleaved_bins_on_gpu, const int32_t idx_target_as_key, const ColRangeInfo &col_range_info, const ColSlotContext &col_slot_context, const std::vector< int8_t > &group_col_widths, const int8_t group_col_compact_width, const std::vector< int64_t > &target_groupby_indices, const size_t entry_count, const CountDistinctDescriptors count_distinct_descriptors, const bool sort_on_gpu_hint, const bool output_columnar, const bool render_output, const bool must_use_baseline_sort, const bool use_streaming_top_n, const bool threads_can_reuse_group_by_buffers)
 
 QueryMemoryDescriptor (const Executor *executor, const size_t entry_count, const QueryDescriptionType query_desc_type)
 
 QueryMemoryDescriptor (const QueryDescriptionType query_desc_type, const int64_t min_val, const int64_t max_val, const bool has_nulls, const std::vector< int8_t > &group_col_widths)
 
 QueryMemoryDescriptor (const TResultSetBufferDescriptor &thrift_query_memory_descriptor)
 
bool operator== (const QueryMemoryDescriptor &other) const
 
std::unique_ptr
< QueryExecutionContext
getQueryExecutionContext (const RelAlgExecutionUnit &, const Executor *executor, const ExecutorDeviceType device_type, const ExecutorDispatchMode dispatch_mode, const int device_id, const shared::TableKey &outer_table_key, const int64_t num_rows, const std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< std::vector< uint64_t >> &frag_offsets, std::shared_ptr< RowSetMemoryOwner >, const bool output_columnar, const bool sort_on_gpu, const size_t thread_idx, RenderInfo *) const
 
bool countDistinctDescriptorsLogicallyEmpty () const
 
const ExecutorgetExecutor () const
 
QueryDescriptionType getQueryDescriptionType () const
 
void setQueryDescriptionType (const QueryDescriptionType val)
 
bool isSingleColumnGroupByWithPerfectHash () const
 
bool hasKeylessHash () const
 
void setHasKeylessHash (const bool val)
 
bool hasInterleavedBinsOnGpu () const
 
void setHasInterleavedBinsOnGpu (const bool val)
 
int32_t getTargetIdxForKey () const
 
void setTargetIdxForKey (const int32_t val)
 
int8_t groupColWidth (const size_t key_idx) const
 
size_t getPrependedGroupColOffInBytes (const size_t group_idx) const
 
size_t getPrependedGroupBufferSizeInBytes () const
 
const auto groupColWidthsBegin () const
 
const auto groupColWidthsEnd () const
 
void clearGroupColWidths ()
 
bool isGroupBy () const
 
void setGroupColCompactWidth (const int8_t val)
 
size_t getColCount () const
 
size_t getSlotCount () const
 
const int8_t getPaddedSlotWidthBytes (const size_t slot_idx) const
 
const int8_t getLogicalSlotWidthBytes (const size_t slot_idx) const
 
void setPaddedSlotWidthBytes (const size_t slot_idx, const int8_t bytes)
 
const int8_t getSlotIndexForSingleSlotCol (const size_t col_idx) const
 
size_t getPaddedColWidthForRange (const size_t offset, const size_t range) const
 
void useConsistentSlotWidthSize (const int8_t slot_width_size)
 
size_t getRowWidth () const
 
int8_t updateActualMinByteWidth (const int8_t actual_min_byte_width) const
 
void addColSlotInfo (const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)
 
void addColSlotInfoFlatBuffer (const int64_t flatbuffer_size)
 
int64_t getFlatBufferSize (const size_t slot_idx) const
 
bool checkSlotUsesFlatBufferFormat (const size_t slot_idx) const
 
int64_t getPaddedSlotBufferSize (const size_t slot_idx) const
 
void clearSlotInfo ()
 
void alignPaddedSlots ()
 
int64_t getTargetGroupbyIndex (const size_t target_idx) const
 
void setAllTargetGroupbyIndices (std::vector< int64_t > group_by_indices)
 
size_t targetGroupbyIndicesSize () const
 
size_t targetGroupbyNegativeIndicesSize () const
 
void clearTargetGroupbyIndices ()
 
size_t getEntryCount () const
 
void setEntryCount (const size_t val)
 
int64_t getMinVal () const
 
int64_t getMaxVal () const
 
int64_t getBucket () const
 
bool hasNulls () const
 
const CountDistinctDescriptorgetCountDistinctDescriptor (const size_t idx) const
 
size_t getCountDistinctDescriptorsSize () const
 
bool sortOnGpu () const
 
bool canOutputColumnar () const
 
bool didOutputColumnar () const
 
void setOutputColumnar (const bool val)
 
bool useStreamingTopN () const
 
bool isLogicalSizedColumnsAllowed () const
 
bool mustUseBaselineSort () const
 
bool threadsCanReuseGroupByBuffers () const
 
void setThreadsCanReuseGroupByBuffers (const bool val)
 
bool forceFourByteFloat () const
 
void setForceFourByteFloat (const bool val)
 
size_t getGroupbyColCount () const
 
size_t getKeyCount () const
 
size_t getBufferColSlotCount () const
 
size_t getBufferSizeBytes (const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const
 
size_t getBufferSizeBytes (const ExecutorDeviceType device_type) const
 
size_t getBufferSizeBytes (const ExecutorDeviceType device_type, const size_t override_entry_count) const
 
const ColSlotContextgetColSlotContext () const
 
bool usesGetGroupValueFast () const
 
bool blocksShareMemory () const
 
bool threadsShareMemory () const
 
bool lazyInitGroups (const ExecutorDeviceType) const
 
bool interleavedBins (const ExecutorDeviceType) const
 
size_t getColOffInBytes (const size_t col_idx) const
 
size_t getColOffInBytesInNextBin (const size_t col_idx) const
 
size_t getNextColOffInBytes (const int8_t *col_ptr, const size_t bin, const size_t col_idx) const
 
size_t getNextColOffInBytesRowOnly (const int8_t *col_ptr, const size_t col_idx) const
 
size_t getColOnlyOffInBytes (const size_t col_idx) const
 
size_t getRowSize () const
 
size_t getColsSize () const
 
size_t getWarpCount () const
 
size_t getCompactByteWidth () const
 
size_t getEffectiveKeyWidth () const
 
bool isWarpSyncRequired (const ExecutorDeviceType) const
 
std::string queryDescTypeToString () const
 
std::string toString () const
 
std::string reductionKey () const
 
bool hasVarlenOutput () const
 
std::optional< size_t > varlenOutputBufferElemSize () const
 
size_t varlenOutputRowSizeToSlot (const size_t slot_idx) const
 
bool slotIsVarlenOutput (const size_t slot_idx) const
 
size_t getAvailableCpuThreads () const
 
void setAvailableCpuThreads (size_t num_available_threads) const
 
std::optional< size_t > getMaxPerDeviceCardinality (const RelAlgExecutionUnit &ra_exe_unit) const
 
bool canUsePerDeviceCardinality (const RelAlgExecutionUnit &ra_exe_unit) const
 

Static Public Member Functions

static TResultSetBufferDescriptor toThrift (const QueryMemoryDescriptor &)
 
static std::unique_ptr
< QueryMemoryDescriptor
init (const Executor *executor, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const ColRangeInfo &col_range_info, const KeylessInfo &keyless_info, const bool allow_multifrag, const ExecutorDeviceType device_type, const int8_t crt_min_byte_width, const bool sort_on_gpu_hint, const size_t shard_count, const size_t max_groups_buffer_entry_count, RenderInfo *render_info, const CountDistinctDescriptors count_distinct_descriptors, const bool must_use_baseline_sort, const bool output_columnar_hint, const bool streaming_top_n_hint, const bool threads_can_reuse_group_by_buffers)
 
static bool many_entries (const int64_t max_val, const int64_t min_val, const int64_t bucket)
 
static bool countDescriptorsLogicallyEmpty (const CountDistinctDescriptors &count_distinct_descriptors)
 
static int8_t pick_target_compact_width (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const int8_t crt_min_byte_width)
 

Protected Member Functions

void resetGroupColWidths (const std::vector< int8_t > &new_group_col_widths)
 

Private Member Functions

size_t getTotalBytesOfColumnarBuffers () const
 
size_t getTotalBytesOfColumnarBuffers (const size_t num_entries_per_column) const
 
size_t getTotalBytesOfColumnarProjections (const size_t projection_count) const
 

Private Attributes

const Executorexecutor_
 
bool allow_multifrag_
 
QueryDescriptionType query_desc_type_
 
bool keyless_hash_
 
bool interleaved_bins_on_gpu_
 
int32_t idx_target_as_key_
 
std::vector< int8_t > group_col_widths_
 
int8_t group_col_compact_width_
 
std::vector< int64_t > target_groupby_indices_
 
size_t entry_count_
 
int64_t min_val_
 
int64_t max_val_
 
int64_t bucket_
 
bool has_nulls_
 
CountDistinctDescriptors count_distinct_descriptors_
 
bool sort_on_gpu_
 
bool output_columnar_
 
bool render_output_
 
bool must_use_baseline_sort_
 
bool use_streaming_top_n_
 
bool threads_can_reuse_group_by_buffers_
 
bool force_4byte_float_
 
ColSlotContext col_slot_context_
 
size_t num_available_threads_ {1}
 

Friends

class ResultSet
 
class QueryExecutionContext
 

Detailed Description

Definition at line 66 of file QueryMemoryDescriptor.h.

Constructor & Destructor Documentation

QueryMemoryDescriptor::QueryMemoryDescriptor ( )

Definition at line 549 of file QueryMemoryDescriptor.cpp.

References Projection.

550  : executor_(nullptr)
551  , allow_multifrag_(false)
553  , keyless_hash_(false)
554  , interleaved_bins_on_gpu_(false)
555  , idx_target_as_key_(0)
557  , entry_count_(0)
558  , min_val_(0)
559  , max_val_(0)
560  , bucket_(0)
561  , has_nulls_(false)
562  , sort_on_gpu_(false)
563  , output_columnar_(false)
564  , render_output_(false)
565  , must_use_baseline_sort_(false)
566  , use_streaming_top_n_(false)
568  , force_4byte_float_(false) {}
QueryDescriptionType query_desc_type_
QueryMemoryDescriptor::QueryMemoryDescriptor ( const Executor executor,
const RelAlgExecutionUnit ra_exe_unit,
const std::vector< InputTableInfo > &  query_infos,
const bool  allow_multifrag,
const bool  keyless_hash,
const bool  interleaved_bins_on_gpu,
const int32_t  idx_target_as_key,
const ColRangeInfo col_range_info,
const ColSlotContext col_slot_context,
const std::vector< int8_t > &  group_col_widths,
const int8_t  group_col_compact_width,
const std::vector< int64_t > &  target_groupby_indices,
const size_t  entry_count,
const CountDistinctDescriptors  count_distinct_descriptors,
const bool  sort_on_gpu_hint,
const bool  output_columnar,
const bool  render_output,
const bool  must_use_baseline_sort,
const bool  use_streaming_top_n,
const bool  threads_can_reuse_group_by_buffers 
)

Definition at line 450 of file QueryMemoryDescriptor.cpp.

References canOutputColumnar(), CHECK, col_slot_context_, count_distinct_descriptors_, countDescriptorsLogicallyEmpty(), executor_, streaming_top_n::get_heap_size(), getEntryCount(), getRowSize(), GroupByBaselineHash, GroupByPerfectHash, isLogicalSizedColumnsAllowed(), keyless_hash_, NonGroupedAggregate, output_columnar_, Projection, query_desc_type_, ColSlotContext::setAllSlotsPaddedSizeToLogicalSize(), ColSlotContext::setAllUnsetSlotsPaddedSize(), sort_on_gpu_, TableFunction, RelAlgExecutionUnit::target_exprs, RelAlgExecutionUnit::use_bump_allocator, use_streaming_top_n_, and ColSlotContext::validate().

471  : executor_(executor)
472  , allow_multifrag_(allow_multifrag)
473  , query_desc_type_(col_range_info.hash_type_)
474  , keyless_hash_(keyless_hash)
475  , interleaved_bins_on_gpu_(interleaved_bins_on_gpu)
476  , idx_target_as_key_(idx_target_as_key)
477  , group_col_widths_(group_col_widths)
478  , group_col_compact_width_(group_col_compact_width)
479  , target_groupby_indices_(target_groupby_indices)
480  , entry_count_(entry_count)
481  , min_val_(col_range_info.min)
482  , max_val_(col_range_info.max)
483  , bucket_(col_range_info.bucket)
484  , has_nulls_(col_range_info.has_nulls)
485  , count_distinct_descriptors_(count_distinct_descriptors)
486  , output_columnar_(false)
487  , render_output_(render_output)
488  , must_use_baseline_sort_(must_use_baseline_sort)
490  , threads_can_reuse_group_by_buffers_(threads_can_reuse_group_by_buffers)
491  , force_4byte_float_(false)
492  , col_slot_context_(col_slot_context)
497 
498  sort_on_gpu_ = sort_on_gpu_hint && canOutputColumnar() && !keyless_hash_;
499  if (sort_on_gpu_) {
500  CHECK(!ra_exe_unit.use_bump_allocator);
501  output_columnar_ = true;
502  } else {
503  switch (query_desc_type_) {
505  output_columnar_ = output_columnar_hint;
506  break;
508  output_columnar_ = output_columnar_hint &&
511  !any_of<kAPPROX_QUANTILE, kMODE>(ra_exe_unit.target_exprs);
512  break;
514  output_columnar_ = output_columnar_hint;
515  break;
517  output_columnar_ = output_columnar_hint &&
520  !any_of<kAPPROX_QUANTILE, kMODE>(ra_exe_unit.target_exprs);
521  break;
522  default:
523  output_columnar_ = false;
524  break;
525  }
526  }
527 
529  // TODO(adb): Ensure fixed size buffer allocations are correct with all logical column
530  // sizes
531  CHECK(!ra_exe_unit.use_bump_allocator);
534  }
535 
536 #ifdef HAVE_CUDA
537  // Check Streaming Top N heap usage, bail if > max slab size, CUDA ONLY
538  if (use_streaming_top_n_ && executor->getDataMgr()->gpusPresent()) {
539  const auto thread_count = executor->blockSize() * executor->gridSize();
540  const auto total_buff_size =
542  if (total_buff_size > executor_->maxGpuSlabSize()) {
543  throw StreamingTopNOOM(total_buff_size);
544  }
545  }
546 #endif
547 }
std::vector< Analyzer::Expr * > target_exprs
bool isLogicalSizedColumnsAllowed() const
QueryDescriptionType hash_type_
bool use_streaming_top_n(const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
std::vector< int64_t > target_groupby_indices_
CountDistinctDescriptors count_distinct_descriptors_
void validate() const
QueryDescriptionType query_desc_type_
size_t get_heap_size(const size_t row_size, const size_t n, const size_t thread_count)
void setAllSlotsPaddedSizeToLogicalSize()
#define CHECK(condition)
Definition: Logger.h:291
std::vector< int8_t > group_col_widths_
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)
void setAllUnsetSlotsPaddedSize(const int8_t padded_size)
int cpu_threads()
Definition: thread_count.h:25

+ Here is the call graph for this function:

QueryMemoryDescriptor::QueryMemoryDescriptor ( const Executor executor,
const size_t  entry_count,
const QueryDescriptionType  query_desc_type 
)

Definition at line 570 of file QueryMemoryDescriptor.cpp.

References output_columnar_, and TableFunction.

573  : executor_(executor)
574  , allow_multifrag_(false)
575  , query_desc_type_(query_desc_type)
576  , keyless_hash_(false)
577  , interleaved_bins_on_gpu_(false)
578  , idx_target_as_key_(0)
580  , entry_count_(entry_count)
581  , min_val_(0)
582  , max_val_(0)
583  , bucket_(0)
584  , has_nulls_(false)
585  , sort_on_gpu_(false)
586  , output_columnar_(false)
587  , render_output_(false)
588  , must_use_baseline_sort_(false)
589  , use_streaming_top_n_(false)
591  , force_4byte_float_(false)
593  if (query_desc_type == QueryDescriptionType::TableFunction) {
594  // Table functions output columns are always columnar
595  output_columnar_ = true;
596  }
597 }
QueryDescriptionType query_desc_type_
int cpu_threads()
Definition: thread_count.h:25
QueryMemoryDescriptor::QueryMemoryDescriptor ( const QueryDescriptionType  query_desc_type,
const int64_t  min_val,
const int64_t  max_val,
const bool  has_nulls,
const std::vector< int8_t > &  group_col_widths 
)

Definition at line 599 of file QueryMemoryDescriptor.cpp.

604  : executor_(nullptr)
605  , allow_multifrag_(false)
606  , query_desc_type_(query_desc_type)
607  , keyless_hash_(false)
608  , interleaved_bins_on_gpu_(false)
609  , idx_target_as_key_(0)
610  , group_col_widths_(group_col_widths)
612  , entry_count_(0)
613  , min_val_(min_val)
614  , max_val_(max_val)
615  , bucket_(0)
616  , has_nulls_(false)
617  , sort_on_gpu_(false)
618  , output_columnar_(false)
619  , render_output_(false)
620  , must_use_baseline_sort_(false)
621  , use_streaming_top_n_(false)
623  , force_4byte_float_(false)
QueryDescriptionType query_desc_type_
std::vector< int8_t > group_col_widths_
int cpu_threads()
Definition: thread_count.h:25
QueryMemoryDescriptor::QueryMemoryDescriptor ( const TResultSetBufferDescriptor &  thrift_query_memory_descriptor)

Member Function Documentation

void QueryMemoryDescriptor::addColSlotInfo ( const std::vector< std::tuple< int8_t, int8_t >> &  slots_for_col)

Definition at line 1219 of file QueryMemoryDescriptor.cpp.

References ColSlotContext::addColumn(), and col_slot_context_.

Referenced by TableFunctionManager::allocate_output_buffers(), ResultSetLogicalValuesBuilder::create(), and TableFunctionExecutionContext::launchGpuCode().

1220  {
1221  col_slot_context_.addColumn(slots_for_col);
1222 }
void addColumn(const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::addColSlotInfoFlatBuffer ( const int64_t  flatbuffer_size)

Definition at line 1224 of file QueryMemoryDescriptor.cpp.

References ColSlotContext::addColumnFlatBuffer(), and col_slot_context_.

Referenced by TableFunctionManager::allocate_output_buffers().

1224  {
1225  col_slot_context_.addColumnFlatBuffer(flatbuffer_size);
1226 }
void addColumnFlatBuffer(const int64_t flatbuffer_size)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::alignPaddedSlots ( )

Definition at line 1232 of file QueryMemoryDescriptor.cpp.

References ColSlotContext::alignPaddedSlots(), col_slot_context_, and sortOnGpu().

1232  {
1234 }
void alignPaddedSlots(const bool sort_on_gpu)

+ Here is the call graph for this function:

bool QueryMemoryDescriptor::blocksShareMemory ( ) const

Definition at line 1139 of file QueryMemoryDescriptor.cpp.

References bucket_, count_distinct_descriptors_, countDescriptorsLogicallyEmpty(), executor_, g_cluster, getGroupbyColCount(), GroupByBaselineHash, GroupByPerfectHash, many_entries(), max_val_, min_val_, Projection, query_desc_type_, render_output_, and TableFunction.

Referenced by canOutputColumnar(), ResultSetReductionJIT::codegen(), QueryMemoryInitializer::computeNumberOfBuffers(), copy_group_by_buffers_from_gpu(), create_dev_group_by_buffers(), and toString().

1139  {
1140  if (g_cluster) {
1141  return true;
1142  }
1144  return true;
1145  }
1146  if (executor_->isCPUOnly() || render_output_ ||
1151  getGroupbyColCount() > 1)) {
1152  return true;
1153  }
1156 }
static bool many_entries(const int64_t max_val, const int64_t min_val, const int64_t bucket)
size_t getGroupbyColCount() const
CountDistinctDescriptors count_distinct_descriptors_
QueryDescriptionType query_desc_type_
bool g_cluster
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::canOutputColumnar ( ) const

Definition at line 1236 of file QueryMemoryDescriptor.cpp.

References blocksShareMemory(), count_distinct_descriptors_, countDescriptorsLogicallyEmpty(), GPU, interleavedBins(), threadsShareMemory(), and usesGetGroupValueFast().

Referenced by QueryMemoryDescriptor().

1236  {
1240 }
CountDistinctDescriptors count_distinct_descriptors_
bool interleavedBins(const ExecutorDeviceType) const
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::canUsePerDeviceCardinality ( const RelAlgExecutionUnit ra_exe_unit) const

Definition at line 1378 of file QueryMemoryDescriptor.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), RelAlgExecutionUnit::join_quals, LEFT, Projection, query_desc_type_, and RelAlgExecutionUnit::target_exprs_union.

1379  {
1380  // union-query needs to consider the "SUM" of each subquery's result
1382  !ra_exe_unit.target_exprs_union.empty()) {
1383  return false;
1384  }
1385  auto is_left_join = [](auto& join_qual) { return join_qual.type == JoinType::LEFT; };
1386  auto& join_quals = ra_exe_unit.join_quals;
1387  return !std::any_of(join_quals.begin(), join_quals.end(), is_left_join);
1388 }
std::vector< Analyzer::Expr * > target_exprs_union
const JoinQualsPerNestingLevel join_quals
QueryDescriptionType query_desc_type_
bool any_of(std::vector< Analyzer::Expr * > const &target_exprs)

+ Here is the call graph for this function:

bool QueryMemoryDescriptor::checkSlotUsesFlatBufferFormat ( const size_t  slot_idx) const
inline

Definition at line 230 of file QueryMemoryDescriptor.h.

References ColSlotContext::checkSlotUsesFlatBufferFormat(), and col_slot_context_.

Referenced by ResultSet::checkSlotUsesFlatBufferFormat(), getPaddedSlotBufferSize(), and target_exprs_to_infos().

230  {
232  }
bool checkSlotUsesFlatBufferFormat(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::clearGroupColWidths ( )
inline

Definition at line 194 of file QueryMemoryDescriptor.h.

References group_col_widths_.

194 { group_col_widths_.clear(); }
std::vector< int8_t > group_col_widths_
void QueryMemoryDescriptor::clearSlotInfo ( )

Definition at line 1228 of file QueryMemoryDescriptor.cpp.

References ColSlotContext::clear(), and col_slot_context_.

1228  {
1230 }

+ Here is the call graph for this function:

void QueryMemoryDescriptor::clearTargetGroupbyIndices ( )
inline

Definition at line 255 of file QueryMemoryDescriptor.h.

References target_groupby_indices_.

255 { target_groupby_indices_.clear(); }
std::vector< int64_t > target_groupby_indices_
static bool QueryMemoryDescriptor::countDescriptorsLogicallyEmpty ( const CountDistinctDescriptors count_distinct_descriptors)
inlinestatic

Definition at line 149 of file QueryMemoryDescriptor.h.

References Invalid.

Referenced by blocksShareMemory(), canOutputColumnar(), countDistinctDescriptorsLogicallyEmpty(), lazyInitGroups(), and QueryMemoryDescriptor().

150  {
151  return std::all_of(count_distinct_descriptors.begin(),
152  count_distinct_descriptors.end(),
153  [](const CountDistinctDescriptor& desc) {
154  return desc.impl_type_ == CountDistinctImplType::Invalid;
155  });
156  }

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::countDistinctDescriptorsLogicallyEmpty ( ) const
inline

Definition at line 158 of file QueryMemoryDescriptor.h.

References count_distinct_descriptors_, and countDescriptorsLogicallyEmpty().

Referenced by QueryMemoryInitializer::allocateCountDistinctGpuMem(), and anonymous_namespace{QueryMemoryInitializer.cpp}::collect_target_expr_metadata().

158  {
160  }
CountDistinctDescriptors count_distinct_descriptors_
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::didOutputColumnar ( ) const
inline

Definition at line 277 of file QueryMemoryDescriptor.h.

References output_columnar_.

Referenced by ResultSetStorage::binSearchRowCount(), TargetExprCodegen::codegen(), ResultSetReductionJIT::codegen(), GroupByAndAggregate::codegen(), GroupByAndAggregate::codegenAggCalls(), GroupByAndAggregate::codegenAggColumnPtr(), TargetExprCodegen::codegenAggregate(), GroupByAndAggregate::codegenGroupBy(), GroupByAndAggregate::codegenMultiColumnBaselineHash(), GroupByAndAggregate::codegenMultiColumnPerfectHash(), GroupByAndAggregate::codegenOutputSlot(), GroupByAndAggregate::codegenSingleColumnPerfectHash(), GroupByAndAggregate::codegenWindowRowPointer(), copy_projection_buffer_from_gpu_columnar(), ResultSetStorage::copyKeyColWise(), ResultSet::createComparator(), ResultSet::didOutputColumnar(), ResultSet::eachCellInColumn(), anonymous_namespace{ResultSetReduction.cpp}::fill_slots(), ResultSetStorage::fillOneEntryColWise(), ResultSetStorage::fillOneEntryRowWise(), ResultSet::fixupQueryMemoryDescriptor(), get_cols_ptr(), ResultSet::getTargetValueFromBufferColwise(), GpuReductionHelperJIT::GpuReductionHelperJIT(), GpuSharedMemCodeBuilder::GpuSharedMemCodeBuilder(), ResultSetStorage::initializeBaselineValueSlots(), anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), ResultSetReductionJIT::isEmpty(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), ResultSet::makeGeoTargetValue(), ResultSetStorage::moveOneEntryToBuffer(), ResultSetStorage::reduce(), ResultSetStorage::reduceOneEntryBaseline(), ResultSetReductionJIT::reduceOneEntryBaselineIdx(), ResultSetStorage::reduceOneEntrySlotsBaseline(), ResultSetStorage::reduceOneSlotBaseline(), ResultSetStorage::reduceSingleRow(), and ResultSetStorage::rewriteAggregateBufferOffsets().

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::forceFourByteFloat ( ) const
inline

Definition at line 296 of file QueryMemoryDescriptor.h.

References force_4byte_float_.

Referenced by ResultSet::makeTargetValue().

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getAvailableCpuThreads ( ) const
inline

Definition at line 364 of file QueryMemoryDescriptor.h.

References num_available_threads_.

Referenced by QueryMemoryInitializer::initRowGroups().

+ Here is the caller graph for this function:

int64_t QueryMemoryDescriptor::getBucket ( ) const
inline

Definition at line 262 of file QueryMemoryDescriptor.h.

References bucket_.

Referenced by GroupByAndAggregate::codegenGroupBy(), and GroupByAndAggregate::codegenSingleColumnPerfectHash().

262 { return bucket_; }

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getBufferColSlotCount ( ) const

Definition at line 1119 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, ColSlotContext::getSlotCount(), and target_groupby_indices_.

Referenced by anonymous_namespace{ResultSetIteration.cpp}::advance_col_buff_to_slot(), QueryMemoryInitializer::copyFromTableFunctionGpuBuffers(), anonymous_namespace{ResultSetReduction.cpp}::fill_slots(), ResultSetStorage::fillOneEntryColWise(), ResultSetStorage::fillOneEntryRowWise(), and QueryMemoryInitializer::setupTableFunctionGpuBuffers().

1119  {
1120  size_t total_slot_count = col_slot_context_.getSlotCount();
1121 
1122  if (target_groupby_indices_.empty()) {
1123  return total_slot_count;
1124  }
1125  return total_slot_count - std::count_if(target_groupby_indices_.begin(),
1127  [](const int64_t i) { return i >= 0; });
1128 }
std::vector< int64_t > target_groupby_indices_
size_t getSlotCount() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getBufferSizeBytes ( const RelAlgExecutionUnit ra_exe_unit,
const unsigned  thread_count,
const ExecutorDeviceType  device_type 
) const

Definition at line 1042 of file QueryMemoryDescriptor.cpp.

References entry_count_, streaming_top_n::get_heap_size(), getRowSize(), SortInfo::limit, anonymous_namespace{Utm.h}::n, SortInfo::offset, RelAlgExecutionUnit::sort_info, and use_streaming_top_n_.

Referenced by QueryMemoryInitializer::applyStreamingTopNOffsetCpu(), QueryMemoryInitializer::copyGroupByBuffersFromGpu(), create_dev_group_by_buffers(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), getBufferSizeBytes(), Executor::launchKernelsViaResourceMgr(), and QueryMemoryInitializer::QueryMemoryInitializer().

1045  {
1046  if (use_streaming_top_n_) {
1047  const size_t n =
1048  ra_exe_unit.sort_info.offset + ra_exe_unit.sort_info.limit.value_or(0);
1049  return streaming_top_n::get_heap_size(getRowSize(), n, thread_count);
1050  }
1051  return getBufferSizeBytes(device_type, entry_count_);
1052 }
size_t getBufferSizeBytes(const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const
std::optional< size_t > limit
size_t get_heap_size(const size_t row_size, const size_t n, const size_t thread_count)
constexpr double n
Definition: Utm.h:38

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getBufferSizeBytes ( const ExecutorDeviceType  device_type) const

Definition at line 1095 of file QueryMemoryDescriptor.cpp.

References entry_count_, and getBufferSizeBytes().

1096  {
1097  return getBufferSizeBytes(device_type, entry_count_);
1098 }
size_t getBufferSizeBytes(const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getBufferSizeBytes ( const ExecutorDeviceType  device_type,
const size_t  entry_count 
) const

Returns total amount of output buffer memory for each device (CPU/GPU)

Columnar: if projection: it returns index buffer + columnar buffer (all non-lazy columns) if table function: only the columnar buffer if group by: it returns the amount required for each group column (assumes 64-bit per group) + columnar buffer (all involved agg columns)

Row-wise: returns required memory per row multiplied by number of entries

Definition at line 1066 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK_GE, executor_, getColsSize(), getRowSize(), getTotalBytesOfColumnarBuffers(), group_col_widths_, interleavedBins(), keyless_hash_, output_columnar_, Projection, query_desc_type_, and TableFunction.

1067  {
1068  if (keyless_hash_ && !output_columnar_) {
1069  CHECK_GE(group_col_widths_.size(), size_t(1));
1070  auto row_bytes = align_to_int64(getColsSize());
1071  return (interleavedBins(device_type) ? executor_->warpSize() : 1) * entry_count *
1072  row_bytes;
1073  }
1074  constexpr size_t row_index_width = sizeof(int64_t);
1075  size_t total_bytes{0};
1076  if (output_columnar_) {
1077  switch (query_desc_type_) {
1079  total_bytes = row_index_width * entry_count + getTotalBytesOfColumnarBuffers();
1080  break;
1082  total_bytes = getTotalBytesOfColumnarBuffers();
1083  break;
1084  default:
1085  total_bytes = sizeof(int64_t) * group_col_widths_.size() * entry_count +
1087  break;
1088  }
1089  } else {
1090  total_bytes = getRowSize() * entry_count;
1091  }
1092  return total_bytes;
1093 }
#define CHECK_GE(x, y)
Definition: Logger.h:306
size_t getTotalBytesOfColumnarBuffers() const
QueryDescriptionType query_desc_type_
bool interleavedBins(const ExecutorDeviceType) const
std::vector< int8_t > group_col_widths_
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getColCount ( ) const

Definition at line 1176 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getColCount().

1176  {
1177  return col_slot_context_.getColCount();
1178 }
size_t getColCount() const

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getColOffInBytes ( const size_t  col_idx) const

Definition at line 900 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK, CHECK_EQ, CHECK_GT, entry_count_, getColOnlyOffInBytes(), getEffectiveKeyWidth(), getFlatBufferSize(), getPaddedSlotWidthBytes(), getPrependedGroupBufferSizeInBytes(), getWarpCount(), group_col_widths_, GroupByPerfectHash, keyless_hash_, output_columnar_, query_desc_type_, and TableFunction.

Referenced by TargetExprCodegen::codegen(), GroupByAndAggregate::codegenAggColumnPtr(), GroupByAndAggregate::codegenOutputSlot(), anonymous_namespace{QueryMemoryInitializer.cpp}::compact_projection_buffer_for_cpu_columnar(), copy_projection_buffer_from_gpu_columnar(), get_cols_ptr(), QueryExecutionContext::groupBufferToDeinterleavedResults(), QueryMemoryInitializer::initRowGroups(), inplace_sort_gpu(), and anonymous_namespace{Execute.cpp}::permute_storage_columnar().

900  {
901  const auto warp_count = getWarpCount();
902  if (output_columnar_) {
903  CHECK_EQ(size_t(1), warp_count);
904  size_t offset{0};
905  if (!keyless_hash_) {
907  }
909  for (size_t index = 0; index < col_idx; ++index) {
910  int8_t column_width = getPaddedSlotWidthBytes(index);
911  if (column_width > 0) {
912  offset += align_to_int64(column_width * entry_count_);
913  } else {
914  int64_t flatbuffer_size = getFlatBufferSize(index);
915  CHECK_GT(flatbuffer_size, 0);
916  offset += align_to_int64(flatbuffer_size);
917  }
918  }
919  } else {
920  for (size_t index = 0; index < col_idx; ++index) {
922  }
923  }
924  return offset;
925  }
926 
927  size_t offset{0};
928  if (keyless_hash_) {
929  // ignore, there's no group column in the output buffer
931  } else {
932  offset += group_col_widths_.size() * getEffectiveKeyWidth();
933  offset = align_to_int64(offset);
934  }
935  offset += getColOnlyOffInBytes(col_idx);
936  return offset;
937 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
size_t getEffectiveKeyWidth() const
#define CHECK_GT(x, y)
Definition: Logger.h:305
size_t getColOnlyOffInBytes(const size_t col_idx) const
size_t getPrependedGroupBufferSizeInBytes() const
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
QueryDescriptionType query_desc_type_
#define CHECK(condition)
Definition: Logger.h:291
std::vector< int8_t > group_col_widths_
int64_t getFlatBufferSize(const size_t slot_idx) const
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getColOffInBytesInNextBin ( const size_t  col_idx) const

Definition at line 980 of file QueryMemoryDescriptor.cpp.

References CHECK_EQ, getPaddedSlotWidthBytes(), getRowSize(), getWarpCount(), group_col_widths_, and output_columnar_.

Referenced by QueryExecutionContext::groupBufferToDeinterleavedResults().

980  {
981  auto warp_count = getWarpCount();
982  if (output_columnar_) {
983  CHECK_EQ(size_t(1), group_col_widths_.size());
984  CHECK_EQ(size_t(1), warp_count);
985  return getPaddedSlotWidthBytes(col_idx);
986  }
987 
988  return warp_count * getRowSize();
989 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
std::vector< int8_t > group_col_widths_

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getColOnlyOffInBytes ( const size_t  col_idx) const

Definition at line 887 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getColOnlyOffInBytes().

Referenced by TargetExprCodegen::codegen(), GroupByAndAggregate::codegenAggColumnPtr(), TargetExprCodegen::codegenAggregate(), getColOffInBytes(), and ResultSetStorage::reduceSingleRow().

887  {
888  return col_slot_context_.getColOnlyOffInBytes(col_idx);
889 }
size_t getColOnlyOffInBytes(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const ColSlotContext& QueryMemoryDescriptor::getColSlotContext ( ) const
inline

Definition at line 311 of file QueryMemoryDescriptor.h.

References col_slot_context_.

Referenced by QueryMemoryInitializer::copyFromTableFunctionGpuBuffers(), ResultSetStorage::reduceEntriesNoCollisionsColWise(), ResultSetReductionJIT::reduceOneEntryTargetsNoCollisions(), and QueryMemoryInitializer::setupTableFunctionGpuBuffers().

311 { return col_slot_context_; }

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getColsSize ( ) const

Definition at line 826 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getAllSlotsAlignedPaddedSize().

Referenced by QueryExecutionContext::copyInitAggValsToDevice(), getBufferSizeBytes(), getRowSize(), QueryExecutionContext::launchCpuCode(), and QueryExecutionContext::sizeofInitAggVals().

826  {
828 }
size_t getAllSlotsAlignedPaddedSize() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getCompactByteWidth ( ) const

Definition at line 848 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getCompactByteWidth().

Referenced by anonymous_namespace{TargetExprBuilder.cpp}::get_initial_agg_val(), and init_agg_val_vec().

848  {
850 }
size_t getCompactByteWidth() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getCountDistinctDescriptorsSize ( ) const
inline
size_t QueryMemoryDescriptor::getEntryCount ( ) const
inline

Definition at line 257 of file QueryMemoryDescriptor.h.

References entry_count_.

Referenced by QueryMemoryInitializer::allocateCountDistinctGpuMem(), QueryMemoryInitializer::applyStreamingTopNOffsetCpu(), QueryMemoryInitializer::applyStreamingTopNOffsetGpu(), ResultSetStorage::binSearchRowCount(), anonymous_namespace{QueryMemoryInitializer.cpp}::check_total_bitmap_memory(), ResultSetReductionJIT::codegen(), GroupByAndAggregate::codegenMultiColumnBaselineHash(), GroupByAndAggregate::codegenMultiColumnPerfectHash(), GpuSharedMemCodeBuilder::codegenReduction(), GroupByAndAggregate::codegenWindowRowPointer(), anonymous_namespace{QueryMemoryInitializer.cpp}::compact_projection_buffer_for_cpu_columnar(), QueryMemoryInitializer::compactProjectionBuffersCpu(), QueryMemoryInitializer::compactProjectionBuffersGpu(), copy_group_by_buffers_from_gpu(), create_dev_group_by_buffers(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), Executor::createKernels(), ResultSet::entryCount(), Executor::executePlanWithGroupBy(), ResultSetStorage::fillOneEntryColWise(), ResultSetStorage::fillOneEntryRowWise(), anonymous_namespace{ResultSetReduction.cpp}::get_matching_group_value_reduction(), ResultSetStorage::getEntryCount(), getPrependedGroupBufferSizeInBytes(), getPrependedGroupColOffInBytes(), ResultSet::getTargetValueFromBufferColwise(), QueryMemoryInitializer::initColumnarGroups(), QueryMemoryInitializer::initGroupByBuffer(), ResultSetStorage::initializeBaselineValueSlots(), ResultSetStorage::initializeColWise(), ResultSetStorage::initializeRowWise(), inplace_sort_gpu(), QueryExecutionContext::launchGpuCode(), ResultSetStorage::moveEntriesToBuffer(), ResultSetStorage::moveOneEntryToBuffer(), QueryMemoryDescriptor(), QueryMemoryInitializer::QueryMemoryInitializer(), ResultSetStorage::reduce(), ResultSetStorage::reduceOneEntryBaseline(), ResultSetStorage::reduceOneEntrySlotsBaseline(), ResultSetStorage::reduceOneSlotBaseline(), and ResultSetStorage::rewriteAggregateBufferOffsets().

257 { return entry_count_; }

+ Here is the caller graph for this function:

const Executor* QueryMemoryDescriptor::getExecutor ( ) const
inline

Definition at line 167 of file QueryMemoryDescriptor.h.

References executor_.

Referenced by anonymous_namespace{Execute.cpp}::build_row_for_empty_input(), ResultSetReductionJIT::codegen(), anonymous_namespace{Execute.cpp}::fill_entries_for_empty_input(), ResultSet::getExecutor(), ResultSet::getVarlenOrderEntry(), ResultSet::makeGeoTargetValue(), and ResultSet::makeVarlenTargetValue().

167 { return executor_; }

+ Here is the caller graph for this function:

int64_t QueryMemoryDescriptor::getFlatBufferSize ( const size_t  slot_idx) const
inline

Definition at line 227 of file QueryMemoryDescriptor.h.

References col_slot_context_, and ColSlotContext::getFlatBufferSize().

Referenced by getColOffInBytes(), and getPaddedSlotBufferSize().

227  {
228  return col_slot_context_.getFlatBufferSize(slot_idx);
229  }
int64_t getFlatBufferSize(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getKeyCount ( ) const
inline

Definition at line 301 of file QueryMemoryDescriptor.h.

References getGroupbyColCount(), and keyless_hash_.

Referenced by anonymous_namespace{Execute.cpp}::permute_storage_columnar().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const int8_t QueryMemoryDescriptor::getLogicalSlotWidthBytes ( const size_t  slot_idx) const

Definition at line 1193 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, ColSlotContext::getSlotInfo(), and SlotSize::logical_size.

Referenced by QueryMemoryInitializer::allocateTDigestsBuffer(), anonymous_namespace{QueryMemoryInitializer.cpp}::check_count_distinct_expr_metadata(), TargetExprCodegen::codegenAggregate(), ResultSet::getTargetValueFromBufferRowwise(), and QueryMemoryInitializer::initializeQuantileParams().

1194  {
1195  return col_slot_context_.getSlotInfo(slot_idx).logical_size;
1196 }
int8_t logical_size
const SlotSize & getSlotInfo(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::optional< size_t > QueryMemoryDescriptor::getMaxPerDeviceCardinality ( const RelAlgExecutionUnit ra_exe_unit) const

Definition at line 1367 of file QueryMemoryDescriptor.cpp.

References anonymous_namespace{Utm.h}::a, and RelAlgExecutionUnit::per_device_cardinality.

1368  {
1369  auto& pdc = ra_exe_unit.per_device_cardinality;
1370  auto by_cardinality = [](auto& a, auto& b) { return a.second < b.second; };
1371  auto itr = std::max_element(pdc.begin(), pdc.end(), by_cardinality);
1372  if (itr != pdc.end() && itr->second > 0) {
1373  return itr->second;
1374  }
1375  return std::nullopt;
1376 }
constexpr double a
Definition: Utm.h:32
std::vector< std::pair< std::vector< size_t >, size_t > > per_device_cardinality
int64_t QueryMemoryDescriptor::getMaxVal ( ) const
inline

Definition at line 261 of file QueryMemoryDescriptor.h.

References max_val_.

Referenced by GroupByAndAggregate::codegenGroupBy().

261 { return max_val_; }

+ Here is the caller graph for this function:

int64_t QueryMemoryDescriptor::getMinVal ( ) const
inline

Definition at line 260 of file QueryMemoryDescriptor.h.

References min_val_.

Referenced by GroupByAndAggregate::codegenSingleColumnPerfectHash().

260 { return min_val_; }

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getNextColOffInBytes ( const int8_t *  col_ptr,
const size_t  bin,
const size_t  col_idx 
) const

Definition at line 991 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK, CHECK_EQ, entry_count_, getPaddedSlotWidthBytes(), getSlotCount(), getWarpCount(), group_col_widths_, and output_columnar_.

993  {
995  size_t offset{0};
996  auto warp_count = getWarpCount();
997  const auto chosen_bytes = getPaddedSlotWidthBytes(col_idx);
998  const auto total_slot_count = getSlotCount();
999  if (col_idx + 1 == total_slot_count) {
1000  if (output_columnar_) {
1001  return (entry_count_ - bin) * chosen_bytes;
1002  } else {
1003  return static_cast<size_t>(align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1004  }
1005  }
1006 
1007  const auto next_chosen_bytes = getPaddedSlotWidthBytes(col_idx + 1);
1008  if (output_columnar_) {
1009  CHECK_EQ(size_t(1), group_col_widths_.size());
1010  CHECK_EQ(size_t(1), warp_count);
1011 
1012  offset = align_to_int64(entry_count_ * chosen_bytes);
1013 
1014  offset += bin * (next_chosen_bytes - chosen_bytes);
1015  return offset;
1016  }
1017 
1018  if (next_chosen_bytes == sizeof(int64_t)) {
1019  return static_cast<size_t>(align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1020  } else {
1021  return chosen_bytes;
1022  }
1023 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
#define CHECK(condition)
Definition: Logger.h:291
std::vector< int8_t > group_col_widths_
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getNextColOffInBytesRowOnly ( const int8_t *  col_ptr,
const size_t  col_idx 
) const

Definition at line 1025 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), getPaddedSlotWidthBytes(), and getSlotCount().

Referenced by QueryMemoryInitializer::initColumnsPerRow().

1026  {
1027  const auto chosen_bytes = getPaddedSlotWidthBytes(col_idx);
1028  const auto total_slot_count = getSlotCount();
1029  if (col_idx + 1 == total_slot_count) {
1030  return static_cast<size_t>(align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1031  }
1032 
1033  const auto next_chosen_bytes = getPaddedSlotWidthBytes(col_idx + 1);
1034 
1035  if (next_chosen_bytes == sizeof(int64_t)) {
1036  return static_cast<size_t>(align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1037  } else {
1038  return chosen_bytes;
1039  }
1040 }
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getPaddedColWidthForRange ( const size_t  offset,
const size_t  range 
) const
inline

Definition at line 210 of file QueryMemoryDescriptor.h.

References getPaddedSlotWidthBytes().

Referenced by result_set::get_byteoff_of_slot(), and ResultSet::makeGeoTargetValue().

210  {
211  size_t ret = 0;
212  for (size_t i = offset; i < offset + range; i++) {
213  ret += static_cast<size_t>(getPaddedSlotWidthBytes(i));
214  }
215  return ret;
216  }
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

int64_t QueryMemoryDescriptor::getPaddedSlotBufferSize ( const size_t  slot_idx) const

Definition at line 939 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), checkSlotUsesFlatBufferFormat(), entry_count_, getFlatBufferSize(), and getPaddedSlotWidthBytes().

Referenced by advance_to_next_columnar_target_buff().

939  {
940  if (checkSlotUsesFlatBufferFormat(slot_idx)) {
941  return align_to_int64(getFlatBufferSize(slot_idx));
942  }
943  int8_t column_width = getPaddedSlotWidthBytes(slot_idx);
944  return align_to_int64(column_width * entry_count_);
945 }
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
int64_t getFlatBufferSize(const size_t slot_idx) const
bool checkSlotUsesFlatBufferFormat(const size_t slot_idx) const
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const int8_t QueryMemoryDescriptor::getPaddedSlotWidthBytes ( const size_t  slot_idx) const

Definition at line 1184 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, ColSlotContext::getSlotInfo(), and SlotSize::padded_size.

Referenced by advance_target_ptr_row_wise(), TargetExprCodegen::codegen(), anonymous_namespace{GpuSharedMemoryUtils.cpp}::codegen_smem_dest_slot_ptr(), TargetExprCodegen::codegenAggregate(), GroupByAndAggregate::codegenOutputSlot(), compact_init_vals(), anonymous_namespace{QueryMemoryInitializer.cpp}::compact_projection_buffer_for_cpu_columnar(), copy_projection_buffer_from_gpu_columnar(), ResultSet::copyColumnIntoBuffer(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), ResultSet::eachCellInColumn(), Executor::executePlanWithoutGroupBy(), result_set::get_width_for_slot(), getColOffInBytes(), getColOffInBytesInNextBin(), getNextColOffInBytes(), getNextColOffInBytesRowOnly(), getPaddedColWidthForRange(), getPaddedSlotBufferSize(), ResultSet::getPaddedSlotWidthBytes(), ResultSet::getTargetValueFromBufferColwise(), ResultSet::getTargetValueFromBufferRowwise(), init_agg_val_vec(), QueryMemoryInitializer::initColumnarGroups(), QueryMemoryInitializer::initColumnsPerRow(), inplace_sort_gpu(), ResultSetReductionJIT::isEmpty(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), ResultSet::makeGeoTargetValue(), TargetExprCodegenBuilder::operator()(), anonymous_namespace{Execute.cpp}::permute_storage_columnar(), ResultSetStorage::reduceEntriesNoCollisionsColWise(), ResultSetReductionJIT::reduceOneAggregateSlot(), ResultSetReductionJIT::reduceOneEntryTargetsNoCollisions(), ResultSetStorage::reduceOneSlot(), ResultSetStorage::reduceSingleRow(), and ResultSetStorage::rewriteAggregateBufferOffsets().

1184  {
1185  return col_slot_context_.getSlotInfo(slot_idx).padded_size;
1186 }
const SlotSize & getSlotInfo(const size_t slot_idx) const
int8_t padded_size

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getPrependedGroupBufferSizeInBytes ( ) const

Definition at line 969 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK, getEntryCount(), getGroupbyColCount(), groupColWidth(), and output_columnar_.

Referenced by getColOffInBytes().

969  {
971  size_t buffer_size{0};
972  for (size_t group_idx = 0; group_idx < getGroupbyColCount(); group_idx++) {
973  buffer_size += align_to_int64(
974  std::max(groupColWidth(group_idx), static_cast<int8_t>(sizeof(int64_t))) *
975  getEntryCount());
976  }
977  return buffer_size;
978 }
int8_t groupColWidth(const size_t key_idx) const
size_t getGroupbyColCount() const
#define CHECK(condition)
Definition: Logger.h:291
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getPrependedGroupColOffInBytes ( const size_t  group_idx) const

Definition at line 951 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK, getEntryCount(), getGroupbyColCount(), groupColWidth(), and output_columnar_.

Referenced by ResultSetStorage::copyKeyColWise(), ResultSetStorage::isEmptyEntryColumnar(), and anonymous_namespace{Execute.cpp}::permute_storage_columnar().

952  {
954  CHECK(group_idx < getGroupbyColCount());
955  size_t offset{0};
956  for (size_t col_idx = 0; col_idx < group_idx; col_idx++) {
957  // TODO(Saman): relax that int64_bit part immediately
958  offset += align_to_int64(
959  std::max(groupColWidth(col_idx), static_cast<int8_t>(sizeof(int64_t))) *
960  getEntryCount());
961  }
962  return offset;
963 }
int8_t groupColWidth(const size_t key_idx) const
size_t getGroupbyColCount() const
#define CHECK(condition)
Definition: Logger.h:291
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

QueryDescriptionType QueryMemoryDescriptor::getQueryDescriptionType ( ) const
inline

Definition at line 169 of file QueryMemoryDescriptor.h.

References query_desc_type_.

Referenced by ResultSetStorage::binSearchRowCount(), ResultSetReductionJIT::codegen(), GroupByAndAggregate::codegen(), GpuReductionHelperJIT::codegen(), GroupByAndAggregate::codegenAggCalls(), GroupByAndAggregate::codegenAggColumnPtr(), GroupByAndAggregate::codegenGroupBy(), GroupByAndAggregate::codegenMultiColumnPerfectHash(), GroupByAndAggregate::codegenOutputSlot(), Executor::collectAllDeviceResults(), copy_projection_buffer_from_gpu_columnar(), Executor::createKernels(), ResultSet::getQueryDescriptionType(), GpuReductionHelperJIT::GpuReductionHelperJIT(), GpuSharedMemCodeBuilder::GpuSharedMemCodeBuilder(), init_agg_val_vec(), QueryMemoryInitializer::initColumnarGroups(), anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), ResultSetReductionJIT::isEmpty(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), isSingleColumnGroupByWithPerfectHash(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), ResultSetStorage::moveEntriesToBuffer(), TargetExprCodegenBuilder::operator()(), ResultSetStorage::reduce(), Executor::reduceMultiDeviceResultSets(), ResultSetStorage::reduceOneEntryBaseline(), ResultSetReductionJIT::reduceOneEntryBaselineIdx(), ResultSetReductionJIT::reduceOneEntryNoCollisionsIdx(), ExecutionKernel::run(), ExecutionKernel::runImpl(), target_exprs_to_infos(), and ResultSet::updateStorageEntryCount().

169 { return query_desc_type_; }
QueryDescriptionType query_desc_type_

+ Here is the caller graph for this function:

std::unique_ptr< QueryExecutionContext > QueryMemoryDescriptor::getQueryExecutionContext ( const RelAlgExecutionUnit ra_exe_unit,
const Executor executor,
const ExecutorDeviceType  device_type,
const ExecutorDispatchMode  dispatch_mode,
const int  device_id,
const shared::TableKey outer_table_key,
const int64_t  num_rows,
const std::vector< std::vector< const int8_t * >> &  col_buffers,
const std::vector< std::vector< uint64_t >> &  frag_offsets,
std::shared_ptr< RowSetMemoryOwner row_set_mem_owner,
const bool  output_columnar,
const bool  sort_on_gpu,
const size_t  thread_idx,
RenderInfo render_info 
) const

Definition at line 693 of file QueryMemoryDescriptor.cpp.

References DEBUG_TIMER, and QueryExecutionContext.

Referenced by ExecutionKernel::runImpl().

707  {
708  auto timer = DEBUG_TIMER(__func__);
709  if (frag_offsets.empty()) {
710  return nullptr;
711  }
712  return std::unique_ptr<QueryExecutionContext>(
713  new QueryExecutionContext(ra_exe_unit,
714  *this,
715  executor,
716  device_type,
717  dispatch_mode,
718  device_id,
719  outer_table_key,
720  num_rows,
721  col_buffers,
722  frag_offsets,
723  row_set_mem_owner,
724  output_columnar,
725  sort_on_gpu,
726  thread_idx,
727  render_info));
728 }
void sort_on_gpu(int64_t *val_buff, int32_t *idx_buff, const uint64_t entry_count, const bool desc, const uint32_t chosen_bytes, ThrustAllocator &alloc, const int device_id)
#define DEBUG_TIMER(name)
Definition: Logger.h:412

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getRowSize ( ) const

Definition at line 830 of file QueryMemoryDescriptor.cpp.

References align_to_int64(), CHECK, getColsSize(), getEffectiveKeyWidth(), group_col_widths_, GroupByPerfectHash, keyless_hash_, output_columnar_, and query_desc_type_.

Referenced by QueryMemoryInitializer::applyStreamingTopNOffsetCpu(), QueryMemoryInitializer::applyStreamingTopNOffsetGpu(), ResultSetLogicalValuesBuilder::build(), GroupByAndAggregate::codegenGroupBy(), GroupByAndAggregate::codegenOutputSlot(), GroupByAndAggregate::codegenWindowRowPointer(), QueryMemoryInitializer::copyGroupByBuffersFromGpu(), create_dev_group_by_buffers(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), getBufferSizeBytes(), getColOffInBytesInNextBin(), QueryMemoryInitializer::initRowGroups(), anonymous_namespace{Execute.cpp}::permute_storage_row_wise(), QueryMemoryInitializer::prepareTopNHeapsDevBuffer(), QueryMemoryDescriptor(), QueryMemoryInitializer::QueryMemoryInitializer(), and ResultSetStorage::reduceSingleRow().

830  {
832  size_t total_bytes{0};
833  if (keyless_hash_) {
834  // ignore, there's no group column in the output buffer
836  } else {
837  total_bytes += group_col_widths_.size() * getEffectiveKeyWidth();
838  total_bytes = align_to_int64(total_bytes);
839  }
840  total_bytes += getColsSize();
841  return align_to_int64(total_bytes);
842 }
size_t getEffectiveKeyWidth() const
QueryDescriptionType query_desc_type_
#define CHECK(condition)
Definition: Logger.h:291
std::vector< int8_t > group_col_widths_
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getRowWidth ( ) const

Definition at line 1209 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getAllSlotsPaddedSize().

Referenced by get_row_bytes().

1209  {
1210  // Note: Actual row size may include padding (see ResultSetBufferAccessors.h)
1212 }
size_t getAllSlotsPaddedSize() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getSlotCount ( ) const

Definition at line 1180 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getSlotCount().

Referenced by QueryMemoryInitializer::allocateModeBuffer(), QueryMemoryInitializer::allocateTDigestsBuffer(), QueryMemoryInitializer::calculateCountDistinctBufferSize(), anonymous_namespace{QueryMemoryInitializer.cpp}::check_count_distinct_expr_metadata(), compact_init_vals(), anonymous_namespace{QueryMemoryInitializer.cpp}::compact_projection_buffer_for_cpu_columnar(), copy_projection_buffer_from_gpu_columnar(), ResultSet::copyColumnIntoBuffer(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), getNextColOffInBytes(), getNextColOffInBytesRowOnly(), QueryExecutionContext::groupBufferToDeinterleavedResults(), init_agg_val_vec(), QueryMemoryInitializer::initColumnarGroups(), QueryMemoryInitializer::initColumnsPerRow(), QueryMemoryInitializer::initializeModeIndexSet(), QueryMemoryInitializer::initializeQuantileParams(), inplace_sort_gpu(), anonymous_namespace{Execute.cpp}::permute_storage_columnar(), and ResultSetStorage::reduceSingleRow().

1180  {
1182 }
size_t getSlotCount() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const int8_t QueryMemoryDescriptor::getSlotIndexForSingleSlotCol ( const size_t  col_idx) const

Definition at line 1198 of file QueryMemoryDescriptor.cpp.

References CHECK_EQ, col_slot_context_, and ColSlotContext::getSlotsForCol().

Referenced by QueryMemoryInitializer::allocateCountDistinctBuffers(), QueryMemoryInitializer::allocateModeBuffer(), QueryMemoryInitializer::allocateTDigestsBuffer(), QueryMemoryInitializer::calculateCountDistinctBufferSize(), anonymous_namespace{QueryMemoryInitializer.cpp}::check_count_distinct_expr_metadata(), QueryMemoryInitializer::initializeModeIndexSet(), and QueryMemoryInitializer::initializeQuantileParams().

1199  {
1200  const auto& col_slots = col_slot_context_.getSlotsForCol(col_idx);
1201  CHECK_EQ(col_slots.size(), size_t(1));
1202  return col_slots.front();
1203 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
const std::vector< size_t > & getSlotsForCol(const size_t col_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

int64_t QueryMemoryDescriptor::getTargetGroupbyIndex ( const size_t  target_idx) const
inline

Definition at line 239 of file QueryMemoryDescriptor.h.

References CHECK_LT, and target_groupby_indices_.

Referenced by ResultSet::getTargetValueFromBufferColwise(), ResultSet::getTargetValueFromBufferRowwise(), ResultSetReductionJIT::reduceOneEntryBaseline(), ResultSetStorage::reduceOneEntrySlotsBaseline(), ResultSetReductionJIT::reduceOneEntryTargetsNoCollisions(), ResultSetReductionJIT::reduceOneSlot(), ResultSetStorage::reduceOneSlot(), and reductionKey().

239  {
240  CHECK_LT(target_idx, target_groupby_indices_.size());
241  return target_groupby_indices_[target_idx];
242  }
std::vector< int64_t > target_groupby_indices_
#define CHECK_LT(x, y)
Definition: Logger.h:303

+ Here is the caller graph for this function:

int32_t QueryMemoryDescriptor::getTargetIdxForKey ( ) const
inline

Definition at line 182 of file QueryMemoryDescriptor.h.

References idx_target_as_key_.

Referenced by ResultSetReductionJIT::isEmpty(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), ResultSetStorage::reduceSingleRow(), and reductionKey().

182 { return idx_target_as_key_; }

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getTotalBytesOfColumnarBuffers ( ) const
private

Returns the maximum total number of bytes (including required paddings) to store all non-lazy columns' results for columnar cases.

Definition at line 857 of file QueryMemoryDescriptor.cpp.

References CHECK, col_slot_context_, entry_count_, ColSlotContext::getTotalBytesOfColumnarBuffers(), and output_columnar_.

Referenced by getBufferSizeBytes(), and getTotalBytesOfColumnarProjections().

857  {
860 }
size_t getTotalBytesOfColumnarBuffers(const size_t entry_count) const
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::getTotalBytesOfColumnarBuffers ( const size_t  num_entries_per_column) const
private

This is a helper function that returns the total number of bytes (including required paddings) to store all non-lazy columns' results for columnar cases.

Definition at line 866 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getTotalBytesOfColumnarBuffers().

867  {
868  return col_slot_context_.getTotalBytesOfColumnarBuffers(num_entries_per_column);
869 }
size_t getTotalBytesOfColumnarBuffers(const size_t entry_count) const

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getTotalBytesOfColumnarProjections ( const size_t  projection_count) const
private

Returns the effective total number of bytes from columnar projections, which includes 1) total number of bytes used to store all non-lazy columns 2) total number of bytes used to store row indices (for lazy fetches, etc.)

NOTE: this function does not represent the buffer sizes dedicated for the results, but the required memory to fill all valid results into a compact new buffer (with no holes in it)

Definition at line 880 of file QueryMemoryDescriptor.cpp.

References getTotalBytesOfColumnarBuffers().

881  {
882  constexpr size_t row_index_width = sizeof(int64_t);
883  return getTotalBytesOfColumnarBuffers(projection_count) +
884  row_index_width * projection_count;
885 }
size_t getTotalBytesOfColumnarBuffers() const

+ Here is the call graph for this function:

size_t QueryMemoryDescriptor::getWarpCount ( ) const

Definition at line 844 of file QueryMemoryDescriptor.cpp.

References executor_, and interleaved_bins_on_gpu_.

Referenced by getColOffInBytes(), getColOffInBytesInNextBin(), and getNextColOffInBytes().

844  {
845  return (interleaved_bins_on_gpu_ ? executor_->warpSize() : 1);
846 }

+ Here is the caller graph for this function:

int8_t QueryMemoryDescriptor::groupColWidth ( const size_t  key_idx) const
inline

Definition at line 185 of file QueryMemoryDescriptor.h.

References CHECK_LT, and group_col_widths_.

Referenced by ResultSetStorage::copyKeyColWise(), getPrependedGroupBufferSizeInBytes(), getPrependedGroupColOffInBytes(), ResultSetStorage::isEmptyEntryColumnar(), and anonymous_namespace{Execute.cpp}::permute_storage_columnar().

185  {
186  CHECK_LT(key_idx, group_col_widths_.size());
187  return group_col_widths_[key_idx];
188  }
#define CHECK_LT(x, y)
Definition: Logger.h:303
std::vector< int8_t > group_col_widths_

+ Here is the caller graph for this function:

const auto QueryMemoryDescriptor::groupColWidthsBegin ( ) const
inline

Definition at line 192 of file QueryMemoryDescriptor.h.

References group_col_widths_.

192 { return group_col_widths_.begin(); }
std::vector< int8_t > group_col_widths_
const auto QueryMemoryDescriptor::groupColWidthsEnd ( ) const
inline

Definition at line 193 of file QueryMemoryDescriptor.h.

References group_col_widths_.

193 { return group_col_widths_.end(); }
std::vector< int8_t > group_col_widths_
bool QueryMemoryDescriptor::hasInterleavedBinsOnGpu ( ) const
inline

Definition at line 179 of file QueryMemoryDescriptor.h.

References interleaved_bins_on_gpu_.

bool QueryMemoryDescriptor::hasNulls ( ) const
inline

Definition at line 264 of file QueryMemoryDescriptor.h.

References has_nulls_.

Referenced by GroupByAndAggregate::codegenGroupBy().

264 { return has_nulls_; }

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::hasVarlenOutput ( ) const
inline

Definition at line 350 of file QueryMemoryDescriptor.h.

References col_slot_context_, and ColSlotContext::hasVarlenOutput().

Referenced by QueryMemoryInitializer::applyStreamingTopNOffsetCpu(), QueryMemoryInitializer::applyStreamingTopNOffsetGpu(), GroupByAndAggregate::codegenVarlenOutputBuffer(), QueryMemoryInitializer::compactProjectionBuffersCpu(), QueryMemoryInitializer::compactProjectionBuffersGpu(), QueryMemoryInitializer::copyGroupByBuffersFromGpu(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), QueryExecutionContext::getRowSet(), query_group_by_template(), and QueryMemoryInitializer::QueryMemoryInitializer().

bool hasVarlenOutput() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::unique_ptr< QueryMemoryDescriptor > QueryMemoryDescriptor::init ( const Executor executor,
const RelAlgExecutionUnit ra_exe_unit,
const std::vector< InputTableInfo > &  query_infos,
const ColRangeInfo col_range_info,
const KeylessInfo keyless_info,
const bool  allow_multifrag,
const ExecutorDeviceType  device_type,
const int8_t  crt_min_byte_width,
const bool  sort_on_gpu_hint,
const size_t  shard_count,
const size_t  max_groups_buffer_entry_count,
RenderInfo render_info,
const CountDistinctDescriptors  count_distinct_descriptors,
const bool  must_use_baseline_sort,
const bool  output_columnar_hint,
const bool  streaming_top_n_hint,
const bool  threads_can_reuse_group_by_buffers 
)
static

Definition at line 240 of file QueryMemoryDescriptor.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::get_col_byte_widths(), RelAlgExecutionUnit::groupby_exprs, and RelAlgExecutionUnit::target_exprs.

Referenced by GroupByAndAggregate::initQueryMemoryDescriptorImpl().

257  {
258  auto group_col_widths = get_col_byte_widths(ra_exe_unit.groupby_exprs);
259  const bool is_group_by{!group_col_widths.empty()};
260 
261  auto col_slot_context = ColSlotContext(ra_exe_unit.target_exprs, {});
262 
263  const auto min_slot_size = QueryMemoryDescriptor::pick_target_compact_width(
264  ra_exe_unit, query_infos, crt_min_byte_width);
265 
266  col_slot_context.setAllSlotsPaddedSize(min_slot_size);
267  col_slot_context.validate();
268 
269  if (!is_group_by) {
270  CHECK(!must_use_baseline_sort);
271 
272  return std::make_unique<QueryMemoryDescriptor>(
273  executor,
274  ra_exe_unit,
275  query_infos,
276  allow_multifrag,
277  false,
278  false,
279  -1,
280  ColRangeInfo{ra_exe_unit.estimator ? QueryDescriptionType::Estimator
282  0,
283  0,
284  0,
285  false},
286  col_slot_context,
287  std::vector<int8_t>{},
288  /*group_col_compact_width=*/0,
289  std::vector<int64_t>{},
290  /*entry_count=*/1,
291  count_distinct_descriptors,
292  false,
293  output_columnar_hint,
294  render_info && render_info->isInSitu(),
295  must_use_baseline_sort,
296  /*use_streaming_top_n=*/false,
297  threads_can_reuse_group_by_buffers);
298  }
299 
300  size_t entry_count = 1;
301  auto actual_col_range_info = col_range_info;
302  bool interleaved_bins_on_gpu = false;
303  bool keyless_hash = false;
304  bool streaming_top_n = false;
305  int8_t group_col_compact_width = 0;
306  int32_t idx_target_as_key = -1;
307  auto output_columnar = output_columnar_hint;
308  std::vector<int64_t> target_groupby_indices;
309 
310  switch (col_range_info.hash_type_) {
312  if (render_info) {
313  // TODO(croot): this can be removed now thanks to the more centralized
314  // NonInsituQueryClassifier code, but keeping it just in case
315  render_info->setNonInSitu();
316  }
317  // keyless hash: whether or not group columns are stored at the beginning of the
318  // output buffer
319  keyless_hash =
320  (!sort_on_gpu_hint ||
322  col_range_info.max, col_range_info.min, col_range_info.bucket)) &&
323  !col_range_info.bucket && !must_use_baseline_sort && keyless_info.keyless;
324 
325  // if keyless, then this target index indicates wheter an entry is empty or not
326  // (acts as a key)
327  idx_target_as_key = keyless_info.target_index;
328 
329  if (group_col_widths.size() > 1) {
330  // col range info max contains the expected cardinality of the output
331  entry_count = static_cast<size_t>(actual_col_range_info.max);
332  actual_col_range_info.bucket = 0;
333  } else {
334  // single column perfect hash
335  entry_count = std::max(
336  GroupByAndAggregate::getBucketedCardinality(col_range_info), int64_t(1));
337  const size_t interleaved_max_threshold{512};
338 
339  if (must_use_baseline_sort) {
340  target_groupby_indices = target_expr_group_by_indices(ra_exe_unit.groupby_exprs,
341  ra_exe_unit.target_exprs);
342  col_slot_context =
343  ColSlotContext(ra_exe_unit.target_exprs, target_groupby_indices);
344  }
345 
346  bool has_varlen_sample_agg = false;
347  for (const auto& target_expr : ra_exe_unit.target_exprs) {
348  if (target_expr->get_contains_agg()) {
349  const auto agg_expr = dynamic_cast<Analyzer::AggExpr*>(target_expr);
350  CHECK(agg_expr);
351  if (agg_expr->get_aggtype() == kSAMPLE &&
352  agg_expr->get_type_info().is_varlen()) {
353  has_varlen_sample_agg = true;
354  break;
355  }
356  }
357  }
358 
359  interleaved_bins_on_gpu = keyless_hash && !has_varlen_sample_agg &&
360  (entry_count <= interleaved_max_threshold) &&
361  (device_type == ExecutorDeviceType::GPU) &&
363  count_distinct_descriptors) &&
364  !output_columnar;
365  }
366  break;
367  }
369  if (render_info) {
370  // TODO(croot): this can be removed now thanks to the more centralized
371  // NonInsituQueryClassifier code, but keeping it just in case
372  render_info->setNonInSitu();
373  }
374  entry_count = shard_count
375  ? (max_groups_buffer_entry_count + shard_count - 1) / shard_count
376  : max_groups_buffer_entry_count;
377  target_groupby_indices = target_expr_group_by_indices(ra_exe_unit.groupby_exprs,
378  ra_exe_unit.target_exprs);
379  col_slot_context = ColSlotContext(ra_exe_unit.target_exprs, target_groupby_indices);
380 
381  group_col_compact_width =
382  output_columnar ? 8
383  : pick_baseline_key_width(ra_exe_unit, query_infos, executor);
384 
385  actual_col_range_info =
387  break;
388  }
390  CHECK(!must_use_baseline_sort);
391 
392  if (streaming_top_n_hint && use_streaming_top_n(ra_exe_unit, output_columnar)) {
393  streaming_top_n = true;
394  entry_count =
395  ra_exe_unit.sort_info.offset + ra_exe_unit.sort_info.limit.value_or(0);
396  } else {
397  if (ra_exe_unit.use_bump_allocator) {
398  output_columnar = false;
399  entry_count = 0;
400  } else {
401  entry_count = ra_exe_unit.scan_limit
402  ? static_cast<size_t>(ra_exe_unit.scan_limit)
403  : max_groups_buffer_entry_count;
404  }
405  }
406 
407  target_groupby_indices = executor->plan_state_->allow_lazy_fetch_
408  ? target_expr_proj_indices(ra_exe_unit)
409  : std::vector<int64_t>{};
410 
411  col_slot_context = ColSlotContext(ra_exe_unit.target_exprs, target_groupby_indices);
412  break;
413  }
414  default:
415  UNREACHABLE() << "Unknown query type";
416  }
417 
418  return std::make_unique<QueryMemoryDescriptor>(executor,
419  ra_exe_unit,
420  query_infos,
421  allow_multifrag,
422  keyless_hash,
423  interleaved_bins_on_gpu,
424  idx_target_as_key,
425  actual_col_range_info,
426  col_slot_context,
427  group_col_widths,
428  group_col_compact_width,
429  target_groupby_indices,
430  entry_count,
431  count_distinct_descriptors,
432  sort_on_gpu_hint,
433  output_columnar,
434  render_info && render_info->isInSitu(),
435  must_use_baseline_sort,
436  streaming_top_n,
437  threads_can_reuse_group_by_buffers);
438 }
std::vector< Analyzer::Expr * > target_exprs
static bool many_entries(const int64_t max_val, const int64_t min_val, const int64_t bucket)
static int64_t getBucketedCardinality(const ColRangeInfo &col_range_info)
std::vector< int64_t > target_expr_proj_indices(const RelAlgExecutionUnit &ra_exe_unit)
const bool keyless
std::vector< int8_t > get_col_byte_widths(const T &col_expr_list)
QueryDescriptionType hash_type_
#define UNREACHABLE()
Definition: Logger.h:338
bool use_streaming_top_n(const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
static int8_t pick_target_compact_width(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const int8_t crt_min_byte_width)
const int32_t target_index
std::vector< int64_t > target_expr_group_by_indices(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const std::vector< Analyzer::Expr * > &target_exprs)
void setNonInSitu()
Definition: RenderInfo.cpp:50
#define CHECK(condition)
Definition: Logger.h:291
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)
int8_t pick_baseline_key_width(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Executor *executor)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::interleavedBins ( const ExecutorDeviceType  device_type) const
bool QueryMemoryDescriptor::isGroupBy ( ) const
inline

Definition at line 196 of file QueryMemoryDescriptor.h.

References group_col_widths_.

Referenced by anonymous_namespace{TargetExprBuilder.cpp}::get_initial_agg_val(), init_agg_val_vec(), QueryMemoryInitializer::initColumnsPerRow(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), and QueryMemoryInitializer::QueryMemoryInitializer().

196 { return !group_col_widths_.empty(); }
std::vector< int8_t > group_col_widths_

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::isLogicalSizedColumnsAllowed ( ) const

Definition at line 1111 of file QueryMemoryDescriptor.cpp.

References g_cluster, output_columnar_, Projection, query_desc_type_, and TableFunction.

Referenced by TargetExprCodegen::codegenAggregate(), TargetExprCodegenBuilder::codegenMultiSlotSampleExpressions(), TargetExprCodegenBuilder::codegenSlotEmptyKey(), init_agg_val_vec(), ResultSet::makeTargetValue(), QueryMemoryDescriptor(), ResultSetStorage::reduceOneSlot(), ResultSetStorage::reduceOneSlotSingleValue(), and setOutputColumnar().

1111  {
1112  // In distributed mode, result sets are serialized using rowwise iterators, so we use
1113  // consistent slot widths for now
1114  return output_columnar_ && !g_cluster &&
1116  query_desc_type_ == QueryDescriptionType::TableFunction);
1117 }
QueryDescriptionType query_desc_type_
bool g_cluster

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::isSingleColumnGroupByWithPerfectHash ( ) const
inline

Definition at line 171 of file QueryMemoryDescriptor.h.

References getGroupbyColCount(), getQueryDescriptionType(), and GroupByPerfectHash.

Referenced by GroupByAndAggregate::codegenGroupBy(), and ResultSet::getTargetValueFromBufferRowwise().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::isWarpSyncRequired ( const ExecutorDeviceType  device_type) const

Definition at line 1168 of file QueryMemoryDescriptor.cpp.

References executor_, and GPU.

Referenced by query_group_by_template().

1169  {
1170  if (device_type == ExecutorDeviceType::GPU) {
1171  return executor_->cudaMgr()->isArchVoltaOrGreaterForAll();
1172  }
1173  return false;
1174 }

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::lazyInitGroups ( const ExecutorDeviceType  device_type) const

Definition at line 1158 of file QueryMemoryDescriptor.cpp.

References count_distinct_descriptors_, countDescriptorsLogicallyEmpty(), GPU, and render_output_.

Referenced by create_dev_group_by_buffers(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), QueryMemoryInitializer::prepareTopNHeapsDevBuffer(), QueryMemoryInitializer::QueryMemoryInitializer(), and toString().

1158  {
1159  return device_type == ExecutorDeviceType::GPU && !render_output_ &&
1161 }
CountDistinctDescriptors count_distinct_descriptors_
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static bool QueryMemoryDescriptor::many_entries ( const int64_t  max_val,
const int64_t  min_val,
const int64_t  bucket 
)
inlinestatic

Definition at line 143 of file QueryMemoryDescriptor.h.

Referenced by blocksShareMemory().

145  {
146  return max_val - min_val > 10000 * std::max(bucket, int64_t(1));
147  }

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::mustUseBaselineSort ( ) const
inline

Definition at line 284 of file QueryMemoryDescriptor.h.

References must_use_baseline_sort_.

Referenced by GroupByAndAggregate::codegenSingleColumnPerfectHash().

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::operator== ( const QueryMemoryDescriptor other) const

Definition at line 626 of file QueryMemoryDescriptor.cpp.

References bucket_, col_slot_context_, count_distinct_descriptors_, force_4byte_float_, group_col_compact_width_, group_col_widths_, has_nulls_, idx_target_as_key_, interleaved_bins_on_gpu_, keyless_hash_, max_val_, min_val_, output_columnar_, query_desc_type_, sort_on_gpu_, target_groupby_indices_, and threads_can_reuse_group_by_buffers_.

626  {
627  // Note that this method does not check ptr reference members (e.g. executor_) or
628  // entry_count_
629  if (query_desc_type_ != other.query_desc_type_) {
630  return false;
631  }
632  if (keyless_hash_ != other.keyless_hash_) {
633  return false;
634  }
636  return false;
637  }
638  if (idx_target_as_key_ != other.idx_target_as_key_) {
639  return false;
640  }
641  if (force_4byte_float_ != other.force_4byte_float_) {
642  return false;
643  }
644  if (group_col_widths_ != other.group_col_widths_) {
645  return false;
646  }
648  return false;
649  }
651  return false;
652  }
653  if (min_val_ != other.min_val_) {
654  return false;
655  }
656  if (max_val_ != other.max_val_) {
657  return false;
658  }
659  if (bucket_ != other.bucket_) {
660  return false;
661  }
662  if (has_nulls_ != other.has_nulls_) {
663  return false;
664  }
665  if (count_distinct_descriptors_.size() != other.count_distinct_descriptors_.size()) {
666  return false;
667  } else {
668  // Count distinct descriptors can legitimately differ in device only.
669  for (size_t i = 0; i < count_distinct_descriptors_.size(); ++i) {
670  auto ref_count_distinct_desc = other.count_distinct_descriptors_[i];
671  auto count_distinct_desc = count_distinct_descriptors_[i];
672  count_distinct_desc.device_type = ref_count_distinct_desc.device_type;
673  if (ref_count_distinct_desc != count_distinct_desc) {
674  return false;
675  }
676  }
677  }
678  if (sort_on_gpu_ != other.sort_on_gpu_) {
679  return false;
680  }
681  if (output_columnar_ != other.output_columnar_) {
682  return false;
683  }
684  if (col_slot_context_ != other.col_slot_context_) {
685  return false;
686  }
688  return false;
689  }
690  return true;
691 }
std::vector< int64_t > target_groupby_indices_
CountDistinctDescriptors count_distinct_descriptors_
QueryDescriptionType query_desc_type_
std::vector< int8_t > group_col_widths_
int8_t QueryMemoryDescriptor::pick_target_compact_width ( const RelAlgExecutionUnit ra_exe_unit,
const std::vector< InputTableInfo > &  query_infos,
const int8_t  crt_min_byte_width 
)
static

Definition at line 730 of file QueryMemoryDescriptor.cpp.

References CHECK, CHECK_EQ, g_bigint_count, anonymous_namespace{QueryMemoryDescriptor.cpp}::get_col_byte_widths(), Analyzer::UOper::get_operand(), Analyzer::Expr::get_type_info(), RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::input_col_descs, anonymous_namespace{QueryMemoryDescriptor.cpp}::is_int_and_no_bigger_than(), kCOUNT, kENCODING_DICT, kUNNEST, and RelAlgExecutionUnit::target_exprs.

733  {
734  if (g_bigint_count) {
735  return sizeof(int64_t);
736  }
737  int8_t compact_width{0};
738  auto col_it = ra_exe_unit.input_col_descs.begin();
739  auto const end = ra_exe_unit.input_col_descs.end();
740  int unnest_array_col_id{std::numeric_limits<int>::min()};
741  for (const auto& groupby_expr : ra_exe_unit.groupby_exprs) {
742  const auto uoper = dynamic_cast<Analyzer::UOper*>(groupby_expr.get());
743  if (uoper && uoper->get_optype() == kUNNEST) {
744  const auto& arg_ti = uoper->get_operand()->get_type_info();
745  CHECK(arg_ti.is_array());
746  const auto& elem_ti = arg_ti.get_elem_type();
747  if (elem_ti.is_string() && elem_ti.get_compression() == kENCODING_DICT) {
748  unnest_array_col_id = (*col_it)->getColId();
749  } else {
750  compact_width = crt_min_byte_width;
751  break;
752  }
753  }
754  if (col_it != end) {
755  ++col_it;
756  }
757  }
758  if (!compact_width &&
759  (ra_exe_unit.groupby_exprs.size() != 1 || !ra_exe_unit.groupby_exprs.front())) {
760  compact_width = crt_min_byte_width;
761  }
762  if (!compact_width) {
763  col_it = ra_exe_unit.input_col_descs.begin();
764  std::advance(col_it, ra_exe_unit.groupby_exprs.size());
765  for (const auto target : ra_exe_unit.target_exprs) {
766  const auto& ti = target->get_type_info();
767  const auto agg = dynamic_cast<const Analyzer::AggExpr*>(target);
768  if (agg && agg->get_arg()) {
769  compact_width = crt_min_byte_width;
770  break;
771  }
772 
773  if (agg) {
774  CHECK_EQ(kCOUNT, agg->get_aggtype());
775  CHECK(!agg->get_is_distinct());
776  if (col_it != end) {
777  ++col_it;
778  }
779  continue;
780  }
781 
782  if (is_int_and_no_bigger_than(ti, 4) ||
783  (ti.is_string() && ti.get_compression() == kENCODING_DICT)) {
784  if (col_it != end) {
785  ++col_it;
786  }
787  continue;
788  }
789 
790  const auto uoper = dynamic_cast<Analyzer::UOper*>(target);
791  if (uoper && uoper->get_optype() == kUNNEST &&
792  (*col_it)->getColId() == unnest_array_col_id) {
793  const auto arg_ti = uoper->get_operand()->get_type_info();
794  CHECK(arg_ti.is_array());
795  const auto& elem_ti = arg_ti.get_elem_type();
796  if (elem_ti.is_string() && elem_ti.get_compression() == kENCODING_DICT) {
797  if (col_it != end) {
798  ++col_it;
799  }
800  continue;
801  }
802  }
803 
804  compact_width = crt_min_byte_width;
805  break;
806  }
807  }
808  if (!compact_width) {
809  size_t total_tuples{0};
810  for (const auto& qi : query_infos) {
811  total_tuples += qi.info.getNumTuples();
812  }
813  return total_tuples <= static_cast<size_t>(std::numeric_limits<uint32_t>::max()) ||
814  unnest_array_col_id != std::numeric_limits<int>::min()
815  ? 4
816  : crt_min_byte_width;
817  } else {
818  // TODO(miyu): relax this condition to allow more cases just w/o padding
819  for (auto wid : get_col_byte_widths(ra_exe_unit.target_exprs)) {
820  compact_width = std::max(compact_width, wid);
821  }
822  return compact_width;
823  }
824 }
std::vector< Analyzer::Expr * > target_exprs
#define CHECK_EQ(x, y)
Definition: Logger.h:301
std::vector< int8_t > get_col_byte_widths(const T &col_expr_list)
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
bool g_bigint_count
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
const Expr * get_operand() const
Definition: Analyzer.h:384
Definition: sqldefs.h:78
bool is_int_and_no_bigger_than(const SQLTypeInfo &ti, const size_t byte_width)
#define CHECK(condition)
Definition: Logger.h:291
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs

+ Here is the call graph for this function:

std::string QueryMemoryDescriptor::queryDescTypeToString ( ) const

Definition at line 1242 of file QueryMemoryDescriptor.cpp.

References Estimator, GroupByBaselineHash, GroupByPerfectHash, NonGroupedAggregate, Projection, query_desc_type_, TableFunction, and UNREACHABLE.

Referenced by reductionKey().

1242  {
1243  switch (query_desc_type_) {
1245  return "Perfect Hash";
1247  return "Baseline Hash";
1249  return "Projection";
1251  return "Table Function";
1253  return "Non-grouped Aggregate";
1255  return "Estimator";
1256  default:
1257  UNREACHABLE();
1258  }
1259  return "";
1260 }
#define UNREACHABLE()
Definition: Logger.h:338
QueryDescriptionType query_desc_type_

+ Here is the caller graph for this function:

std::string QueryMemoryDescriptor::reductionKey ( ) const

Definition at line 1288 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, getEffectiveKeyWidth(), getGroupbyColCount(), getTargetGroupbyIndex(), getTargetIdxForKey(), join(), keyless_hash_, queryDescTypeToString(), targetGroupbyIndicesSize(), to_string(), ColSlotContext::toString(), and toString().

Referenced by ResultSetReductionJIT::cacheKey(), and toString().

1288  {
1289  std::string str;
1290  str += "Query Memory Descriptor State\n";
1291  str += "\tQuery Type: " + queryDescTypeToString() + "\n";
1292  str +=
1293  "\tKeyless Hash: " + ::toString(keyless_hash_) +
1294  (keyless_hash_ ? ", target index for key: " + std::to_string(getTargetIdxForKey())
1295  : "") +
1296  "\n";
1297  str += "\tEffective key width: " + std::to_string(getEffectiveKeyWidth()) + "\n";
1298  str += "\tNumber of group columns: " + std::to_string(getGroupbyColCount()) + "\n";
1299  const auto group_indices_size = targetGroupbyIndicesSize();
1300  if (group_indices_size) {
1301  std::vector<std::string> group_indices_strings;
1302  for (size_t target_idx = 0; target_idx < group_indices_size; ++target_idx) {
1303  group_indices_strings.push_back(std::to_string(getTargetGroupbyIndex(target_idx)));
1304  }
1305  str += "\tTarget group by indices: " +
1306  boost::algorithm::join(group_indices_strings, ",") + "\n";
1307  }
1308  str += "\t" + col_slot_context_.toString();
1309  return str;
1310 }
int64_t getTargetGroupbyIndex(const size_t target_idx) const
std::string toString() const
std::string join(T const &container, std::string const &delim)
size_t getEffectiveKeyWidth() const
std::string to_string(char const *&&v)
size_t getGroupbyColCount() const
size_t targetGroupbyIndicesSize() const
std::string toString() const
std::string queryDescTypeToString() const
int32_t getTargetIdxForKey() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::resetGroupColWidths ( const std::vector< int8_t > &  new_group_col_widths)
inlineprotected

Definition at line 376 of file QueryMemoryDescriptor.h.

References group_col_widths_.

376  {
377  group_col_widths_ = new_group_col_widths;
378  }
std::vector< int8_t > group_col_widths_
void QueryMemoryDescriptor::setAllTargetGroupbyIndices ( std::vector< int64_t >  group_by_indices)
inline

Definition at line 244 of file QueryMemoryDescriptor.h.

References target_groupby_indices_.

244  {
245  target_groupby_indices_ = group_by_indices;
246  }
std::vector< int64_t > target_groupby_indices_
void QueryMemoryDescriptor::setAvailableCpuThreads ( size_t  num_available_threads) const
inline

Definition at line 366 of file QueryMemoryDescriptor.h.

References num_available_threads_.

Referenced by ExecutionKernel::runImpl().

366  {
367  num_available_threads_ = num_available_threads;
368  }

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::setEntryCount ( const size_t  val)
inline

Definition at line 258 of file QueryMemoryDescriptor.h.

References entry_count_.

Referenced by Executor::executePlanWithGroupBy(), Executor::reduceMultiDeviceResultSets(), ResultSetStorage::updateEntryCount(), and ResultSet::updateStorageEntryCount().

258 { entry_count_ = val; }

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::setForceFourByteFloat ( const bool  val)
inline

Definition at line 297 of file QueryMemoryDescriptor.h.

References force_4byte_float_.

void QueryMemoryDescriptor::setGroupColCompactWidth ( const int8_t  val)
inline

Definition at line 198 of file QueryMemoryDescriptor.h.

References group_col_compact_width_.

void QueryMemoryDescriptor::setHasInterleavedBinsOnGpu ( const bool  val)
inline

Definition at line 180 of file QueryMemoryDescriptor.h.

References interleaved_bins_on_gpu_.

void QueryMemoryDescriptor::setHasKeylessHash ( const bool  val)
inline

Definition at line 177 of file QueryMemoryDescriptor.h.

References keyless_hash_.

void QueryMemoryDescriptor::setOutputColumnar ( const bool  val)

Definition at line 1100 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, isLogicalSizedColumnsAllowed(), output_columnar_, and ColSlotContext::setAllSlotsPaddedSizeToLogicalSize().

1100  {
1101  output_columnar_ = val;
1104  }
1105 }
bool isLogicalSizedColumnsAllowed() const
void setAllSlotsPaddedSizeToLogicalSize()

+ Here is the call graph for this function:

void QueryMemoryDescriptor::setPaddedSlotWidthBytes ( const size_t  slot_idx,
const int8_t  bytes 
)

Definition at line 1188 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::setPaddedSlotWidthBytes().

Referenced by TargetExprCodegenBuilder::operator()().

1189  {
1190  col_slot_context_.setPaddedSlotWidthBytes(slot_idx, bytes);
1191 }
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void QueryMemoryDescriptor::setQueryDescriptionType ( const QueryDescriptionType  val)
inline

Definition at line 170 of file QueryMemoryDescriptor.h.

References query_desc_type_.

170 { query_desc_type_ = val; }
QueryDescriptionType query_desc_type_
void QueryMemoryDescriptor::setTargetIdxForKey ( const int32_t  val)
inline

Definition at line 183 of file QueryMemoryDescriptor.h.

References idx_target_as_key_.

void QueryMemoryDescriptor::setThreadsCanReuseGroupByBuffers ( const bool  val)
inline

Definition at line 290 of file QueryMemoryDescriptor.h.

References threads_can_reuse_group_by_buffers_.

290  {
292  }
bool QueryMemoryDescriptor::slotIsVarlenOutput ( const size_t  slot_idx) const
inline

Definition at line 360 of file QueryMemoryDescriptor.h.

References col_slot_context_, and ColSlotContext::slotIsVarlen().

Referenced by advance_target_ptr_row_wise(), and ResultSet::makeGeoTargetValue().

360  {
361  return col_slot_context_.slotIsVarlen(slot_idx);
362  }
bool slotIsVarlen(const size_t slot_idx) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::sortOnGpu ( ) const
inline

Definition at line 274 of file QueryMemoryDescriptor.h.

References sort_on_gpu_.

Referenced by alignPaddedSlots(), QueryExecutionContext::launchGpuCode(), ExecutionKernel::runImpl(), and use_speculative_top_n().

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::targetGroupbyIndicesSize ( ) const
inline
size_t QueryMemoryDescriptor::targetGroupbyNegativeIndicesSize ( ) const
inline

Definition at line 249 of file QueryMemoryDescriptor.h.

References target_groupby_indices_.

249  {
250  return std::count_if(
251  target_groupby_indices_.begin(),
253  [](const int64_t& target_group_by_index) { return target_group_by_index < 0; });
254  }
std::vector< int64_t > target_groupby_indices_
bool QueryMemoryDescriptor::threadsCanReuseGroupByBuffers ( ) const
inline

Definition at line 286 of file QueryMemoryDescriptor.h.

References threads_can_reuse_group_by_buffers_.

Referenced by Executor::launchKernelsViaResourceMgr(), QueryMemoryInitializer::QueryMemoryInitializer(), and Executor::reduceMultiDeviceResults().

286  {
288  }

+ Here is the caller graph for this function:

std::string QueryMemoryDescriptor::toString ( ) const

Definition at line 1262 of file QueryMemoryDescriptor.cpp.

References allow_multifrag_, blocksShareMemory(), bucket_, entry_count_, executor_, g_enable_lazy_fetch, GPU, interleaved_bins_on_gpu_, lazyInitGroups(), max_val_, min_val_, must_use_baseline_sort_, output_columnar_, reductionKey(), render_output_, sort_on_gpu_, threadsShareMemory(), to_string(), use_streaming_top_n_, and usesGetGroupValueFast().

Referenced by Executor::createKernels(), and reductionKey().

1262  {
1263  auto str = reductionKey();
1264  str += "\tAllow Multifrag: " + ::toString(allow_multifrag_) + "\n";
1265  str += "\tInterleaved Bins on GPU: " + ::toString(interleaved_bins_on_gpu_) + "\n";
1266  str += "\tBlocks Share Memory: " + ::toString(blocksShareMemory()) + "\n";
1267  str += "\tThreads Share Memory: " + ::toString(threadsShareMemory()) + "\n";
1268  str += "\tUses Fast Group Values: " + ::toString(usesGetGroupValueFast()) + "\n";
1269  str +=
1270  "\tLazy Init Groups (GPU): " + ::toString(lazyInitGroups(ExecutorDeviceType::GPU)) +
1271  "\n";
1272  str += "\tEntry Count: " + std::to_string(entry_count_) + "\n";
1273  str += "\tMin Val (perfect hash only): " + std::to_string(min_val_) + "\n";
1274  str += "\tMax Val (perfect hash only): " + std::to_string(max_val_) + "\n";
1275  str += "\tBucket Val (perfect hash only): " + std::to_string(bucket_) + "\n";
1276  str += "\tSort on GPU: " + ::toString(sort_on_gpu_) + "\n";
1277  str += "\tUse Streaming Top N: " + ::toString(use_streaming_top_n_) + "\n";
1278  str += "\tOutput Columnar: " + ::toString(output_columnar_) + "\n";
1279  auto const allow_lazy_fetch = executor_->plan_state_
1280  ? executor_->plan_state_->allow_lazy_fetch_
1282  str += "\tAllow Lazy Fetch: " + ::toString(allow_lazy_fetch) + "\n";
1283  str += "\tRender Output: " + ::toString(render_output_) + "\n";
1284  str += "\tUse Baseline Sort: " + ::toString(must_use_baseline_sort_) + "\n";
1285  return str;
1286 }
std::string toString() const
bool g_enable_lazy_fetch
Definition: Execute.cpp:132
std::string to_string(char const *&&v)
bool lazyInitGroups(const ExecutorDeviceType) const
std::string reductionKey() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static TResultSetBufferDescriptor QueryMemoryDescriptor::toThrift ( const QueryMemoryDescriptor )
static
int8_t QueryMemoryDescriptor::updateActualMinByteWidth ( const int8_t  actual_min_byte_width) const

Definition at line 1214 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::getMinPaddedByteSize().

1215  {
1216  return col_slot_context_.getMinPaddedByteSize(actual_min_byte_width);
1217 }
int8_t getMinPaddedByteSize(const int8_t actual_min_byte_width) const

+ Here is the call graph for this function:

void QueryMemoryDescriptor::useConsistentSlotWidthSize ( const int8_t  slot_width_size)

Definition at line 1205 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, and ColSlotContext::setAllSlotsSize().

1205  {
1206  col_slot_context_.setAllSlotsSize(slot_width_size);
1207 }
void setAllSlotsSize(const int8_t slot_width_size)

+ Here is the call graph for this function:

bool QueryMemoryDescriptor::usesGetGroupValueFast ( ) const

Definition at line 1130 of file QueryMemoryDescriptor.cpp.

References getGroupbyColCount(), GroupByPerfectHash, and query_desc_type_.

Referenced by canOutputColumnar(), GroupByAndAggregate::codegen(), GroupByAndAggregate::codegenSingleColumnPerfectHash(), and toString().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool QueryMemoryDescriptor::useStreamingTopN ( ) const
inline
std::optional< size_t > QueryMemoryDescriptor::varlenOutputBufferElemSize ( ) const

Definition at line 1334 of file QueryMemoryDescriptor.cpp.

References col_slot_context_, ColSlotContext::getSlotCount(), and ColSlotContext::varlenOutputElementSize().

Referenced by TargetExprCodegen::codegenAggregate(), create_dev_group_by_buffers(), QueryMemoryInitializer::createAndInitializeGroupByBufferGpu(), QueryExecutionContext::launchGpuCode(), and QueryMemoryInitializer::QueryMemoryInitializer().

1334  {
1335  int64_t buffer_element_size{0};
1336  for (size_t i = 0; i < col_slot_context_.getSlotCount(); i++) {
1337  try {
1338  const auto slot_element_size = col_slot_context_.varlenOutputElementSize(i);
1339  if (slot_element_size < 0) {
1340  return std::nullopt;
1341  }
1342  buffer_element_size += slot_element_size;
1343  } catch (...) {
1344  continue;
1345  }
1346  }
1347  return buffer_element_size;
1348 }
int64_t varlenOutputElementSize(const size_t slot_idx) const
size_t getSlotCount() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t QueryMemoryDescriptor::varlenOutputRowSizeToSlot ( const size_t  slot_idx) const

Definition at line 1350 of file QueryMemoryDescriptor.cpp.

References CHECK_LT, col_slot_context_, ColSlotContext::getSlotCount(), and ColSlotContext::varlenOutputElementSize().

Referenced by TargetExprCodegen::codegenAggregate().

1350  {
1351  int64_t buffer_element_size{0};
1353  for (size_t i = 0; i < slot_idx; i++) {
1354  try {
1355  const auto slot_element_size = col_slot_context_.varlenOutputElementSize(i);
1356  if (slot_element_size < 0) {
1357  continue;
1358  }
1359  buffer_element_size += slot_element_size;
1360  } catch (...) {
1361  continue;
1362  }
1363  }
1364  return buffer_element_size;
1365 }
int64_t varlenOutputElementSize(const size_t slot_idx) const
#define CHECK_LT(x, y)
Definition: Logger.h:303
size_t getSlotCount() const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Friends And Related Function Documentation

friend class QueryExecutionContext
friend

Definition at line 423 of file QueryMemoryDescriptor.h.

Referenced by getQueryExecutionContext().

friend class ResultSet
friend

Definition at line 422 of file QueryMemoryDescriptor.h.

Member Data Documentation

bool QueryMemoryDescriptor::allow_multifrag_
private

Definition at line 382 of file QueryMemoryDescriptor.h.

Referenced by toString().

int64_t QueryMemoryDescriptor::bucket_
private

Definition at line 399 of file QueryMemoryDescriptor.h.

Referenced by blocksShareMemory(), getBucket(), operator==(), and toString().

const Executor* QueryMemoryDescriptor::executor_
private
bool QueryMemoryDescriptor::force_4byte_float_
private

Definition at line 408 of file QueryMemoryDescriptor.h.

Referenced by forceFourByteFloat(), operator==(), and setForceFourByteFloat().

int8_t QueryMemoryDescriptor::group_col_compact_width_
private
bool QueryMemoryDescriptor::has_nulls_
private

Definition at line 400 of file QueryMemoryDescriptor.h.

Referenced by hasNulls(), and operator==().

int32_t QueryMemoryDescriptor::idx_target_as_key_
private

Definition at line 386 of file QueryMemoryDescriptor.h.

Referenced by getTargetIdxForKey(), operator==(), and setTargetIdxForKey().

bool QueryMemoryDescriptor::interleaved_bins_on_gpu_
private
bool QueryMemoryDescriptor::keyless_hash_
private
int64_t QueryMemoryDescriptor::max_val_
private

Definition at line 398 of file QueryMemoryDescriptor.h.

Referenced by blocksShareMemory(), getMaxVal(), operator==(), and toString().

int64_t QueryMemoryDescriptor::min_val_
private

Definition at line 396 of file QueryMemoryDescriptor.h.

Referenced by blocksShareMemory(), getMinVal(), operator==(), and toString().

bool QueryMemoryDescriptor::must_use_baseline_sort_
private

Definition at line 405 of file QueryMemoryDescriptor.h.

Referenced by mustUseBaselineSort(), and toString().

size_t QueryMemoryDescriptor::num_available_threads_ {1}
mutableprivate

Definition at line 416 of file QueryMemoryDescriptor.h.

Referenced by getAvailableCpuThreads(), and setAvailableCpuThreads().

bool QueryMemoryDescriptor::render_output_
private

Definition at line 404 of file QueryMemoryDescriptor.h.

Referenced by blocksShareMemory(), lazyInitGroups(), and toString().

bool QueryMemoryDescriptor::sort_on_gpu_
private

Definition at line 402 of file QueryMemoryDescriptor.h.

Referenced by operator==(), QueryMemoryDescriptor(), sortOnGpu(), and toString().

std::vector<int64_t> QueryMemoryDescriptor::target_groupby_indices_
private
bool QueryMemoryDescriptor::threads_can_reuse_group_by_buffers_
private
bool QueryMemoryDescriptor::use_streaming_top_n_
private

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