35 const size_t num_count_distinct_descs =
37 for (
size_t i = 0; i < num_count_distinct_descs; i++) {
44 int64_t total_bytes{0};
55 if (total_bytes >= 2 * 1000 * 1000 * 1000L) {
63 if (render_allocator_map) {
67 const auto gpu_idx = 0;
69 return reinterpret_cast<int64_t*
>(render_allocator_ptr->alloc(numBytes));
76 if (frag_offsets.size() < 2) {
79 const auto frag_size = frag_offsets[1] - frag_offsets[0];
80 for (
size_t i = 2; i < frag_offsets.size(); ++i) {
81 const auto curr_size = frag_offsets[i] - frag_offsets[i - 1];
82 if (curr_size != frag_size) {
86 return !frag_size ? std::numeric_limits<int64_t>::max()
87 :
static_cast<int64_t
>(frag_size);
91 const std::vector<std::vector<uint64_t>>& frag_offsets) {
92 if (frag_offsets.empty()) {
95 std::vector<int64_t> frag_sizes;
96 for (
size_t tab_idx = 0; tab_idx < frag_offsets[0].size(); ++tab_idx) {
97 std::vector<uint64_t> tab_offs;
98 for (
auto& offsets : frag_offsets) {
99 tab_offs.push_back(offsets[tab_idx]);
107 const std::vector<Analyzer::Expr*>& target_exprs,
108 const std::vector<int64_t>& table_frag_sizes) {
109 std::vector<int64_t> col_frag_sizes;
110 for (
auto expr : target_exprs) {
111 if (
const auto col_var = dynamic_cast<Analyzer::ColumnVar*>(expr)) {
112 if (col_var->get_rte_idx() < 0) {
113 CHECK_EQ(-1, col_var->get_rte_idx());
114 col_frag_sizes.push_back(int64_t(-1));
116 col_frag_sizes.push_back(table_frag_sizes[col_var->get_rte_idx()]);
119 col_frag_sizes.push_back(int64_t(-1));
122 return col_frag_sizes;
126 const std::vector<Analyzer::Expr*>& target_exprs,
127 const std::vector<std::vector<uint64_t>>& table_frag_offsets) {
128 std::vector<std::vector<int64_t>> col_frag_offsets;
129 for (
auto& table_offsets : table_frag_offsets) {
130 std::vector<int64_t> col_offsets;
131 for (
auto expr : target_exprs) {
132 if (
const auto col_var = dynamic_cast<Analyzer::ColumnVar*>(expr)) {
133 if (col_var->get_rte_idx() < 0) {
134 CHECK_EQ(-1, col_var->get_rte_idx());
135 col_offsets.push_back(int64_t(-1));
137 CHECK_LT(static_cast<size_t>(col_var->get_rte_idx()), table_offsets.size());
138 col_offsets.push_back(
139 static_cast<int64_t>(table_offsets[col_var->get_rte_idx()]));
142 col_offsets.push_back(int64_t(-1));
145 col_frag_offsets.push_back(col_offsets);
147 return col_frag_offsets;
158 const bool output_columnar,
161 const std::vector<std::vector<const int8_t*>>& col_buffers,
162 const std::vector<std::vector<uint64_t>>& frag_offsets,
165 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
167 const Executor* executor)
168 : num_rows_(num_rows)
169 , row_set_mem_owner_(row_set_mem_owner)
170 , init_agg_vals_(executor->plan_state_->init_agg_vals_)
171 ,
num_buffers_(computeNumberOfBuffers(query_mem_desc, device_type, executor))
177 CHECK(!sort_on_gpu || output_columnar);
180 if (consistent_frag_sizes.empty()) {
191 if (render_allocator_map || !query_mem_desc.
isGroupBy()) {
203 ? executor->blockSize() * executor->gridSize()
206 size_t group_buffer_size{0};
211 group_buffer_size = num_rows * query_mem_desc.
getRowSize();
220 CHECK_GE(group_buffer_size,
size_t(0));
222 std::unique_ptr<int64_t, CheckedAllocDeleter> group_by_buffer_template;
224 group_by_buffer_template.reset(
227 if (output_columnar) {
229 query_mem_desc, group_by_buffer_template.get(),
init_agg_vals_, executor);
231 auto rows_ptr = group_by_buffer_template.get();
234 query_mem_desc.
interleavedBins(device_type) ? executor->warpSize() : 1;
236 const auto node_count_size = thread_count *
sizeof(int64_t);
237 memset(rows_ptr, 0, node_count_size);
239 const auto rows_offset =
241 memset(rows_ptr + thread_count, -1, rows_offset - node_count_size);
242 rows_ptr += rows_offset /
sizeof(int64_t);
243 actual_entry_count = n * thread_count;
262 ? executor->blockSize()
268 const auto actual_group_buffer_size =
269 group_buffer_size + index_buffer_qw *
sizeof(int64_t);
270 CHECK_GE(actual_group_buffer_size, group_buffer_size);
273 for (
size_t i = 0; i < group_buffers_count; i += step) {
274 auto group_by_buffer =
277 CHECK(group_by_buffer_template);
278 memcpy(group_by_buffer + index_buffer_qw,
279 group_by_buffer_template.get(),
282 if (!render_allocator_map) {
286 for (
size_t j = 1; j < step; ++j) {
289 const auto column_frag_offsets =
291 const auto column_frag_sizes =
295 executor->getColLazyFetchInfo(ra_exe_unit.
target_exprs),
304 result_sets_.back()->allocateStorage(reinterpret_cast<int8_t*>(group_by_buffer),
305 executor->plan_state_->init_agg_vals_);
306 for (
size_t j = 1; j < step; ++j) {
318 const std::vector<std::vector<const int8_t*>>& col_buffers,
319 const std::vector<std::vector<uint64_t>>& frag_offsets,
320 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
322 const Executor* executor)
323 : num_rows_(num_rows)
324 , row_set_mem_owner_(row_set_mem_owner)
335 if (consistent_frag_sizes.empty()) {
340 size_t group_buffer_size{0};
343 group_buffer_size =
query_mem_desc.getBufferSizeBytes(device_type, num_rows_);
344 CHECK_GE(group_buffer_size,
size_t(0));
346 std::unique_ptr<int64_t, CheckedAllocDeleter> group_by_buffer_template;
348 group_by_buffer_template.reset(
351 query_mem_desc, group_by_buffer_template.get(), init_agg_vals_, executor);
354 const auto index_buffer_qw =
358 const auto actual_group_buffer_size =
359 group_buffer_size + index_buffer_qw *
sizeof(int64_t);
360 CHECK_GE(actual_group_buffer_size, group_buffer_size);
365 memcpy(group_by_buffer + index_buffer_qw,
366 group_by_buffer_template.get(),
369 group_by_buffers_.push_back(group_by_buffer);
370 row_set_mem_owner_->addGroupByBuffer(group_by_buffer);
372 const auto column_frag_offsets =
374 const auto column_frag_sizes =
376 result_sets_.emplace_back(
387 result_sets_.back()->allocateStorage(reinterpret_cast<int8_t*>(group_by_buffer),
395 const size_t warp_size,
396 const Executor* executor) {
398 const size_t row_size{query_mem_desc.
getRowSize()};
404 const auto query_mem_desc_fixedup =
408 CHECK(warp_size >= 1);
409 CHECK(key_count == 1);
410 for (
size_t warp_idx = 0; warp_idx < warp_size; ++warp_idx) {
412 ++bin, buffer_ptr += row_size) {
414 &buffer_ptr[col_base_off],
424 ++bin, buffer_ptr += row_size) {
427 &buffer_ptr[col_base_off],
436 template <
typename T>
438 static_assert(
sizeof(T) <=
sizeof(int64_t),
"Unsupported template type");
439 for (uint32_t i = 0; i < entry_count; ++i) {
440 buffer_ptr[i] = init_val;
442 return reinterpret_cast<int8_t*
>(buffer_ptr + entry_count);
451 const Executor* executor) {
452 CHECK(groups_buffer);
453 for (
const auto target_expr : executor->plan_state_->target_exprs_) {
463 for (
size_t i = 0; i < key_count; ++i) {
464 buffer_ptr = initColumnarBuffer<int64_t>(
reinterpret_cast<int64_t*
>(buffer_ptr),
470 int32_t init_val_idx = 0;
473 CHECK_LT(static_cast<size_t>(init_val_idx), init_vals.size());
476 buffer_ptr = initColumnarBuffer<int8_t>(
480 buffer_ptr = initColumnarBuffer<int16_t>(
reinterpret_cast<int16_t*
>(buffer_ptr),
481 init_vals[init_val_idx++],
485 buffer_ptr = initColumnarBuffer<int32_t>(
reinterpret_cast<int32_t*
>(buffer_ptr),
486 init_vals[init_val_idx++],
490 buffer_ptr = initColumnarBuffer<int64_t>(
reinterpret_cast<int64_t*
>(buffer_ptr),
491 init_vals[init_val_idx++],
509 const std::vector<ssize_t>& bitmap_sizes) {
510 int8_t* col_ptr = row_ptr;
511 size_t init_vec_idx = 0;
512 for (
size_t col_idx = 0; col_idx < query_mem_desc.
getSlotCount();
514 const ssize_t bm_sz{bitmap_sizes[col_idx]};
516 if (!bm_sz || !query_mem_desc.
isGroupBy()) {
518 CHECK_LT(init_vec_idx, init_vals.size());
519 init_val = init_vals[init_vec_idx++];
530 *col_ptr =
static_cast<int8_t
>(init_val);
533 *
reinterpret_cast<int16_t*
>(col_ptr) = (int16_t)init_val;
536 *
reinterpret_cast<int32_t*
>(col_ptr) = (int32_t)init_val;
539 *
reinterpret_cast<int64_t*
>(col_ptr) = init_val;
556 size_t total_bytes_per_entry{0};
557 const size_t num_count_distinct_descs =
559 for (
size_t i = 0; i < num_count_distinct_descs; i++) {
565 total_bytes_per_entry += count_distinct_desc.bitmapPaddedSizeBytes();
586 const Executor* executor) {
588 std::vector<ssize_t> agg_bitmap_size(deferred ?
agg_col_count : 0);
590 CHECK_GE(agg_col_count, executor->plan_state_->target_exprs_.size());
591 for (
size_t target_idx = 0; target_idx < executor->plan_state_->target_exprs_.size();
593 const auto target_expr = executor->plan_state_->target_exprs_[target_idx];
596 CHECK(agg_info.is_agg &&
598 CHECK(!agg_info.sql_type.is_varlen());
601 CHECK_LT(static_cast<size_t>(agg_col_idx), agg_col_count);
605 const auto& count_distinct_desc =
609 const auto bitmap_byte_sz = count_distinct_desc.bitmapPaddedSizeBytes();
611 agg_bitmap_size[agg_col_idx] = bitmap_byte_sz;
618 agg_bitmap_size[agg_col_idx] = -1;
626 return agg_bitmap_size;
635 return reinterpret_cast<int64_t
>(ptr);
637 auto count_distinct_buffer =
static_cast<int8_t*
>(
checked_calloc(bitmap_byte_sz, 1));
638 row_set_mem_owner_->addCountDistinctBuffer(count_distinct_buffer, bitmap_byte_sz,
true);
639 return reinterpret_cast<int64_t
>(count_distinct_buffer);
643 auto count_distinct_set =
new std::set<int64_t>();
645 return reinterpret_cast<int64_t
>(count_distinct_set);
654 const unsigned block_size_x,
655 const unsigned grid_size_x) {
657 const auto thread_count = block_size_x * grid_size_x;
658 const auto total_buff_size =
663 std::vector<CUdeviceptr> dev_buffers(thread_count);
665 for (
size_t i = 0; i < thread_count; ++i) {
666 dev_buffers[i] = dev_buffer;
671 reinterpret_cast<int8_t*>(dev_buffers.data()),
677 thread_count *
sizeof(int64_t));
680 reinterpret_cast<int8_t*>(dev_buffer + thread_count *
sizeof(int64_t)),
682 thread_count * n *
sizeof(int64_t));
685 reinterpret_cast<int64_t*>(
687 reinterpret_cast<int64_t*>(init_agg_vals_dev_ptr),
691 query_mem_desc.
getRowSize() /
sizeof(int64_t),
697 return {
reinterpret_cast<CUdeviceptr>(dev_ptr), dev_buffer};
706 const unsigned block_size_x,
707 const unsigned grid_size_x,
708 const int8_t warp_size,
709 const bool can_sort_on_gpu,
710 const bool output_columnar,
713 if (render_allocator) {
717 CHECK(!output_columnar);
719 return prepareTopNHeapsDevBuffer(
720 query_mem_desc, init_agg_vals_dev_ptr, n, device_id, block_size_x, grid_size_x);
736 if (render_allocator) {
740 CHECK(!render_allocator);
745 auto group_by_dev_buffer = dev_group_by_buffers.second;
747 int8_t* col_widths_dev_ptr{
nullptr};
748 if (output_columnar) {
749 std::vector<int8_t> compact_col_widths(col_count);
750 for (
size_t idx = 0; idx < col_count; ++idx) {
755 col_widths_dev_ptr, compact_col_widths.data(), col_count *
sizeof(int8_t));
757 const int8_t warp_count =
760 if (output_columnar) {
762 reinterpret_cast<int64_t*>(group_by_dev_buffer),
763 reinterpret_cast<const int64_t*>(init_agg_vals_dev_ptr),
764 dev_group_by_buffers.entry_count,
775 reinterpret_cast<int64_t*>(init_agg_vals_dev_ptr),
776 dev_group_by_buffers.entry_count,
779 query_mem_desc.
getRowSize() /
sizeof(int64_t),
785 group_by_dev_buffer += groups_buffer_size;
788 return dev_group_by_buffers;
794 const unsigned block_size_x,
795 const unsigned grid_size_x) {
818 : executor->blockSize() *
827 int8_t* projection_buffer,
828 const size_t projection_count) {
831 constexpr
size_t row_index_width =
sizeof(int64_t);
832 size_t buffer_offset1{projection_count * row_index_width};
834 for (
size_t i = 0; i < query_mem_desc.
getSlotCount(); i++) {
836 auto column_proj_size =
839 if (buffer_offset1 + column_proj_size >= buffer_offset2) {
841 std::memmove(projection_buffer + buffer_offset1,
842 projection_buffer + buffer_offset2,
845 std::memcpy(projection_buffer + buffer_offset1,
846 projection_buffer + buffer_offset2,
858 const size_t projection_count) {
859 const auto num_allocated_rows =
870 result_sets_.front()->updateStorageEntryCount(num_allocated_rows);
877 const size_t projection_count,
878 const int device_id) {
880 const auto num_allocated_rows =
886 gpu_group_by_buffers,
894 result_sets_.front()->updateStorageEntryCount(num_allocated_rows);
900 const size_t entry_count,
903 const unsigned block_size_x,
904 const unsigned grid_size_x,
906 const bool prepend_index_buffer)
const {
907 const auto thread_count = block_size_x * grid_size_x;
909 size_t total_buff_size{0};
922 gpu_group_by_buffers.
second,
927 prepend_index_buffer);
950 const unsigned total_thread_count,
951 const int device_id) {
955 const auto rows_copy = pick_top_n_rows_from_dev_heaps(
957 reinterpret_cast<int64_t*>(gpu_group_by_buffers.
second),
std::vector< Analyzer::Expr * > target_exprs
size_t getSlotCount() const
size_t getBufferSizeBytes(const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const
void initGroups(const QueryMemoryDescriptor &query_mem_desc, int64_t *groups_buffer, const std::vector< int64_t > &init_vals, const int32_t groups_buffer_entry_count, const size_t warp_size, const Executor *executor)
RenderAllocator * getRenderAllocator(size_t device_id)
bool use_streaming_top_n(const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
std::vector< ssize_t > allocateCountDistinctBuffers(const QueryMemoryDescriptor &query_mem_desc, const bool deferred, const Executor *executor)
const int32_t groups_buffer_size return groups_buffer
const int64_t const uint32_t const uint32_t const uint32_t agg_col_count
bool countDistinctDescriptorsLogicallyEmpty() const
size_t getEntryCount() const
bool useCudaBuffers() const
const int8_t const int64_t * num_rows
size_t count_distinct_bitmap_mem_bytes_
int64_t * alloc_group_by_buffer(const size_t numBytes, RenderAllocatorMap *render_allocator_map)
void compact_projection_buffer_for_cpu_columnar(const QueryMemoryDescriptor &query_mem_desc, int8_t *projection_buffer, const size_t projection_count)
GpuGroupByBuffers create_dev_group_by_buffers(DeviceAllocator *cuda_allocator, const std::vector< int64_t * > &group_by_buffers, const QueryMemoryDescriptor &query_mem_desc, const unsigned block_size_x, const unsigned grid_size_x, const int device_id, const ExecutorDispatchMode dispatch_mode, const int64_t num_input_rows, const bool prepend_index_buffer, const bool always_init_group_by_on_host, const bool use_bump_allocator, Allocator *insitu_allocator)
void fill_empty_key(void *key_ptr, const size_t key_count, const size_t key_width)
Streaming Top N algorithm.
TargetInfo get_target_info(const PointerType target_expr, const bool bigint_count)
const size_t num_buffers_
size_t get_rows_offset_of_heaps(const size_t n, const size_t thread_count)
std::vector< int64_t > init_agg_val_vec(const std::vector< TargetInfo > &targets, const QueryMemoryDescriptor &query_mem_desc)
unsigned long long CUdeviceptr
bool hasKeylessHash() const
void init_columnar_group_by_buffer_on_device(int64_t *groups_buffer, const int64_t *init_vals, const uint32_t groups_buffer_entry_count, const uint32_t key_count, const uint32_t agg_col_count, const int8_t *col_sizes, const bool need_padding, const bool keyless, const int8_t key_size, const size_t block_size_x, const size_t grid_size_x)
CUdeviceptr count_distinct_bitmap_mem_
void check_total_bitmap_memory(const QueryMemoryDescriptor &query_mem_desc)
size_t getNextColOffInBytes(const int8_t *col_ptr, const size_t bin, const size_t col_idx) const
size_t getEffectiveKeyWidth() const
const int64_t const uint32_t groups_buffer_entry_count
int8_t * initColumnarBuffer(T *buffer_ptr, const T init_val, const uint32_t entry_count)
size_t computeNumberOfBuffers(const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type, const Executor *executor) const
size_t getRowSize() const
size_t g_max_memory_allocation_size
void init_group_by_buffer_on_device(int64_t *groups_buffer, const int64_t *init_vals, const uint32_t groups_buffer_entry_count, const uint32_t key_count, const uint32_t key_width, const uint32_t row_size_quad, const bool keyless, const int8_t warp_size, const size_t block_size_x, const size_t grid_size_x)
std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
void compactProjectionBuffersGpu(const QueryMemoryDescriptor &query_mem_desc, Data_Namespace::DataMgr *data_mgr, const GpuGroupByBuffers &gpu_group_by_buffers, const size_t projection_count, const int device_id)
bool blocksShareMemory() const
std::vector< int64_t > init_agg_vals_
size_t getGroupbyColCount() const
void * checked_malloc(const size_t size)
void applyStreamingTopNOffsetCpu(const QueryMemoryDescriptor &query_mem_desc, const RelAlgExecutionUnit &ra_exe_unit)
bool lazyInitGroups(const ExecutorDeviceType) const
const int32_t groups_buffer_size return nullptr
void * checked_calloc(const size_t nmemb, const size_t size)
size_t getAllocatedSize() const
bool is_distinct_target(const TargetInfo &target_info)
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
int8_t * count_distinct_bitmap_crt_ptr_
const std::shared_ptr< Analyzer::Estimator > estimator
boost::multiprecision::number< boost::multiprecision::cpp_int_backend< 64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void > > checked_int64_t
size_t getCountDistinctDescriptorsSize() const
int64_t allocateCountDistinctSet()
void compactProjectionBuffersCpu(const QueryMemoryDescriptor &query_mem_desc, const size_t projection_count)
std::vector< int64_t * > group_by_buffers_
void initColumnarGroups(const QueryMemoryDescriptor &query_mem_desc, int64_t *groups_buffer, const std::vector< int64_t > &init_vals, const Executor *executor)
const CountDistinctDescriptor & getCountDistinctDescriptor(const size_t idx) const
count_distinct_bitmap_mem_(0)
size_t bitmapPaddedSizeBytes() const
std::vector< int8_t > get_rows_copy_from_heaps(const int64_t *heaps, const size_t heaps_size, const size_t n, const size_t thread_count)
void copy_group_by_buffers_from_gpu(Data_Namespace::DataMgr *data_mgr, const std::vector< int64_t * > &group_by_buffers, const size_t groups_buffer_size, const CUdeviceptr group_by_dev_buffers_mem, const QueryMemoryDescriptor &query_mem_desc, const unsigned block_size_x, const unsigned grid_size_x, const int device_id, const bool prepend_index_buffer)
std::vector< int64_t > get_consistent_frags_sizes(const std::vector< std::vector< uint64_t >> &frag_offsets)
static QueryMemoryDescriptor fixupQueryMemoryDescriptor(const QueryMemoryDescriptor &)
void copyGroupByBuffersFromGpu(Data_Namespace::DataMgr *data_mgr, const QueryMemoryDescriptor &query_mem_desc, const size_t entry_count, const GpuGroupByBuffers &gpu_group_by_buffers, const RelAlgExecutionUnit *ra_exe_unit, const unsigned block_size_x, const unsigned grid_size_x, const int device_id, const bool prepend_index_buffer) const
count_distinct_bitmap_host_mem_(nullptr)
bool didOutputColumnar() const
size_t get_heap_size(const size_t row_size, const size_t n, const size_t thread_count)
device_allocator_(device_allocator)
bool interleavedBins(const ExecutorDeviceType) const
bool threadsShareMemory() const
QueryMemoryInitializer(const RelAlgExecutionUnit &ra_exe_unit, const QueryMemoryDescriptor &query_mem_desc, const int device_id, const ExecutorDeviceType device_type, const ExecutorDispatchMode dispatch_mode, const bool output_columnar, const bool sort_on_gpu, const int64_t num_rows, const std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< std::vector< uint64_t >> &frag_offsets, RenderAllocatorMap *render_allocator_map, RenderInfo *render_info, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, DeviceAllocator *gpu_allocator, const Executor *executor)
void applyStreamingTopNOffsetGpu(Data_Namespace::DataMgr *data_mgr, const QueryMemoryDescriptor &query_mem_desc, const GpuGroupByBuffers &gpu_group_by_buffers, const RelAlgExecutionUnit &ra_exe_unit, const unsigned total_thread_count, const int device_id)
const auto getGroupByBuffersSize() const
std::vector< TargetInfo > target_exprs_to_infos(const std::vector< Analyzer::Expr * > &targets, const QueryMemoryDescriptor &query_mem_desc)
Basic constructors and methods of the row set interface.
void copy_projection_buffer_from_gpu_columnar(Data_Namespace::DataMgr *data_mgr, const GpuGroupByBuffers &gpu_group_by_buffers, const QueryMemoryDescriptor &query_mem_desc, int8_t *projection_buffer, const size_t projection_count, const int device_id)
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)
count_distinct_bitmap_crt_ptr_(nullptr)
int64_t get_consistent_frag_size(const std::vector< uint64_t > &frag_offsets)
const int64_t * init_vals
int8_t * count_distinct_bitmap_host_mem_
count_distinct_bitmap_mem_bytes_(0)
const int8_t getSlotIndexForSingleSlotCol(const size_t col_idx) const
const int8_t getLogicalSlotWidthBytes(const size_t slot_idx) const
size_t getColOffInBytes(const size_t col_idx) const
std::vector< std::unique_ptr< ResultSet > > result_sets_
void allocateCountDistinctGpuMem(const QueryMemoryDescriptor &query_mem_desc)
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)
int64_t allocateCountDistinctBitmap(const size_t bitmap_byte_sz)
void initColumnPerRow(const QueryMemoryDescriptor &query_mem_desc, int8_t *row_ptr, const size_t bin, const std::vector< int64_t > &init_vals, const std::vector< ssize_t > &bitmap_sizes)
std::vector< std::vector< int64_t > > get_col_frag_offsets(const std::vector< Analyzer::Expr * > &target_exprs, const std::vector< std::vector< uint64_t >> &table_frag_offsets)