OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
QueryMemoryDescriptor.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "QueryMemoryDescriptor.h"
18 
19 #include "../Execute.h"
20 #include "../ExpressionRewrite.h"
21 #include "../GroupByAndAggregate.h"
22 #include "../StreamingTopN.h"
23 #include "../UsedColumnsVisitor.h"
24 #include "ColSlotContext.h"
25 
26 #include <boost/algorithm/cxx11/any_of.hpp>
27 
29 extern bool g_enable_columnar_output;
30 extern size_t g_streaming_topn_max;
31 
32 namespace {
33 
34 bool is_int_and_no_bigger_than(const SQLTypeInfo& ti, const size_t byte_width) {
35  if (!ti.is_integer()) {
36  return false;
37  }
38  return get_bit_width(ti) <= (byte_width * 8);
39 }
40 
42  return range.getIntMin() > INT32_MIN && range.getIntMax() < EMPTY_KEY_32 - 1;
43 }
44 
45 std::vector<int64_t> target_expr_group_by_indices(
46  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby_exprs,
47  const std::vector<Analyzer::Expr*>& target_exprs) {
48  std::vector<int64_t> indices(target_exprs.size(), -1);
49  for (size_t target_idx = 0; target_idx < target_exprs.size(); ++target_idx) {
50  const auto target_expr = target_exprs[target_idx];
51  if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
52  continue;
53  }
54  const auto var_expr = dynamic_cast<const Analyzer::Var*>(target_expr);
55  if (var_expr && var_expr->get_which_row() == Analyzer::Var::kGROUPBY) {
56  indices[target_idx] = var_expr->get_varno() - 1;
57  continue;
58  }
59  }
60  return indices;
61 }
62 
63 std::vector<int64_t> target_expr_proj_indices(const RelAlgExecutionUnit& ra_exe_unit) {
64  if (ra_exe_unit.input_descs.size() > 1 ||
65  !ra_exe_unit.sort_info.order_entries.empty()) {
66  return {};
67  }
68  std::vector<int64_t> target_indices(ra_exe_unit.target_exprs.size(), -1);
69  UsedColumnsVisitor columns_visitor;
70  std::unordered_set<shared::ColumnKey> used_columns;
71  for (const auto& simple_qual : ra_exe_unit.simple_quals) {
72  const auto crt_used_columns = columns_visitor.visit(simple_qual.get());
73  used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
74  }
75  for (const auto& qual : ra_exe_unit.quals) {
76  const auto crt_used_columns = columns_visitor.visit(qual.get());
77  used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
78  }
79  for (const auto& target : ra_exe_unit.target_exprs) {
80  const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target);
81  if (col_var) {
82  const auto cd = get_column_descriptor_maybe(col_var->getColumnKey());
83  if (!cd || !cd->isVirtualCol) {
84  continue;
85  }
86  }
87  const auto crt_used_columns = columns_visitor.visit(target);
88  used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
89  }
90  for (size_t target_idx = 0; target_idx < ra_exe_unit.target_exprs.size();
91  ++target_idx) {
92  const auto target_expr = ra_exe_unit.target_exprs[target_idx];
93  CHECK(target_expr);
94  const auto& ti = target_expr->get_type_info();
95  // TODO: add proper lazy fetch for varlen types in result set
96  if (ti.is_varlen()) {
97  continue;
98  }
99  const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
100  if (!col_var) {
101  continue;
102  }
103  if (!ti.is_varlen() &&
104  used_columns.find(col_var->getColumnKey()) == used_columns.end()) {
105  // setting target index to be zero so that later it can be decoded properly (in lazy
106  // fetch, the zeroth target index indicates the corresponding rowid column for the
107  // projected entry)
108  target_indices[target_idx] = 0;
109  }
110  }
111  return target_indices;
112 }
113 
115  const size_t group_col_width) {
116  if (range.getType() == ExpressionRangeType::Invalid) {
117  return sizeof(int64_t);
118  }
119  switch (range.getType()) {
121  if (group_col_width == sizeof(int64_t) && range.hasNulls()) {
122  return sizeof(int64_t);
123  }
124  return is_valid_int32_range(range) ? sizeof(int32_t) : sizeof(int64_t);
127  return sizeof(int64_t); // No compaction for floating point yet.
128  default:
129  UNREACHABLE();
130  }
131  return sizeof(int64_t);
132 }
133 
134 // TODO(miyu): make sure following setting of compact width is correct in all cases.
136  const std::vector<InputTableInfo>& query_infos,
137  const Executor* executor) {
138  int8_t compact_width{4};
139  for (const auto& groupby_expr : ra_exe_unit.groupby_exprs) {
140  const auto expr_range = getExpressionRange(groupby_expr.get(), query_infos, executor);
141  compact_width = std::max(compact_width,
143  expr_range, groupby_expr->get_type_info().get_size()));
144  }
145  return compact_width;
146 }
147 
148 bool use_streaming_top_n(const RelAlgExecutionUnit& ra_exe_unit,
149  const bool output_columnar) {
150  if (g_cluster) {
151  return false; // TODO(miyu)
152  }
153 
154  for (const auto target_expr : ra_exe_unit.target_exprs) {
155  if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
156  return false;
157  }
158  if (dynamic_cast<const Analyzer::WindowFunction*>(target_expr)) {
159  return false;
160  }
161  }
162 
163  // TODO: Allow streaming top n for columnar output
164  auto limit_value = ra_exe_unit.sort_info.limit.value_or(0);
165  if (!output_columnar && ra_exe_unit.sort_info.order_entries.size() == 1 &&
166  limit_value > 0 &&
168  const auto only_order_entry = ra_exe_unit.sort_info.order_entries.front();
169  CHECK_GT(only_order_entry.tle_no, int(0));
170  CHECK_LE(static_cast<size_t>(only_order_entry.tle_no),
171  ra_exe_unit.target_exprs.size());
172  const auto order_entry_expr = ra_exe_unit.target_exprs[only_order_entry.tle_no - 1];
173  const auto n = ra_exe_unit.sort_info.offset + limit_value;
174  if ((order_entry_expr->get_type_info().is_number() ||
175  order_entry_expr->get_type_info().is_time()) &&
176  n <= g_streaming_topn_max) {
177  return true;
178  }
179  }
180 
181  return false;
182 }
183 
184 template <class T>
185 inline std::vector<int8_t> get_col_byte_widths(const T& col_expr_list) {
186  std::vector<int8_t> col_widths;
187  size_t col_expr_idx = 0;
188  for (const auto& col_expr : col_expr_list) {
189  if (!col_expr) {
190  // row index
191  col_widths.push_back(sizeof(int64_t));
192  } else {
193  bool is_varlen_projection{false};
194  if constexpr (std::is_same<T, std::list<std::shared_ptr<Analyzer::Expr>>>::value) {
196  !(std::dynamic_pointer_cast<const Analyzer::GeoExpr>(col_expr) == nullptr);
197  } else {
199  !(dynamic_cast<const Analyzer::GeoExpr*>(col_expr) == nullptr);
200  }
201 
202  if (is_varlen_projection) {
203  col_widths.push_back(sizeof(int64_t));
204  ++col_expr_idx;
205  continue;
206  }
207  const auto agg_info = get_target_info(col_expr, g_bigint_count);
208  const auto chosen_type = get_compact_type(agg_info);
209  if ((chosen_type.is_string() && chosen_type.get_compression() == kENCODING_NONE) ||
210  chosen_type.is_array()) {
211  col_widths.push_back(sizeof(int64_t));
212  col_widths.push_back(sizeof(int64_t));
213  ++col_expr_idx;
214  continue;
215  }
216  if (chosen_type.is_geometry()) {
217  for (auto i = 0; i < chosen_type.get_physical_coord_cols(); ++i) {
218  col_widths.push_back(sizeof(int64_t));
219  col_widths.push_back(sizeof(int64_t));
220  }
221  ++col_expr_idx;
222  continue;
223  }
224  const auto col_expr_bitwidth = get_bit_width(chosen_type);
225  CHECK_EQ(size_t(0), col_expr_bitwidth % 8);
226  col_widths.push_back(static_cast<int8_t>(col_expr_bitwidth >> 3));
227  // for average, we'll need to keep the count as well
228  if (agg_info.agg_kind == kAVG) {
229  CHECK(agg_info.is_agg);
230  col_widths.push_back(sizeof(int64_t));
231  }
232  }
233  ++col_expr_idx;
234  }
235  return col_widths;
236 }
237 
238 } // namespace
239 
240 std::unique_ptr<QueryMemoryDescriptor> QueryMemoryDescriptor::init(
241  const Executor* executor,
242  const RelAlgExecutionUnit& ra_exe_unit,
243  const std::vector<InputTableInfo>& query_infos,
244  const ColRangeInfo& col_range_info,
245  const KeylessInfo& keyless_info,
246  const bool allow_multifrag,
247  const ExecutorDeviceType device_type,
248  const int8_t crt_min_byte_width,
249  const bool sort_on_gpu_hint,
250  const size_t shard_count,
251  const size_t max_groups_buffer_entry_count,
252  RenderInfo* render_info,
253  const CountDistinctDescriptors count_distinct_descriptors,
254  const bool must_use_baseline_sort,
255  const bool output_columnar_hint,
256  const bool streaming_top_n_hint,
257  const bool threads_can_reuse_group_by_buffers) {
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 }
439 
440 namespace {
441 template <SQLAgg... agg_types>
442 bool any_of(std::vector<Analyzer::Expr*> const& target_exprs) {
443  return boost::algorithm::any_of(target_exprs, [=](Analyzer::Expr const* expr) {
444  auto const* const agg = dynamic_cast<Analyzer::AggExpr const*>(expr);
445  return agg && (... || (agg_types == agg->get_aggtype()));
446  });
447 }
448 } // namespace
449 
451  const Executor* executor,
452  const RelAlgExecutionUnit& ra_exe_unit,
453  const std::vector<InputTableInfo>& query_infos,
454  const bool allow_multifrag,
455  const bool keyless_hash,
456  const bool interleaved_bins_on_gpu,
457  const int32_t idx_target_as_key,
458  const ColRangeInfo& col_range_info,
459  const ColSlotContext& col_slot_context,
460  const std::vector<int8_t>& group_col_widths,
461  const int8_t group_col_compact_width,
462  const std::vector<int64_t>& target_groupby_indices,
463  const size_t entry_count,
464  const CountDistinctDescriptors count_distinct_descriptors,
465  const bool sort_on_gpu_hint,
466  const bool output_columnar_hint,
467  const bool render_output,
468  const bool must_use_baseline_sort,
469  const bool use_streaming_top_n,
470  const bool threads_can_reuse_group_by_buffers)
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)
489  , use_streaming_top_n_(use_streaming_top_n)
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)
493  , num_available_threads_(cpu_threads()) {
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 }
548 
550  : executor_(nullptr)
551  , allow_multifrag_(false)
552  , query_desc_type_(QueryDescriptionType::Projection)
553  , keyless_hash_(false)
554  , interleaved_bins_on_gpu_(false)
555  , idx_target_as_key_(0)
556  , group_col_compact_width_(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)
567  , threads_can_reuse_group_by_buffers_(false)
568  , force_4byte_float_(false) {}
569 
571  const size_t entry_count,
572  const QueryDescriptionType query_desc_type)
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)
579  , group_col_compact_width_(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)
590  , threads_can_reuse_group_by_buffers_(false)
591  , force_4byte_float_(false)
592  , num_available_threads_(cpu_threads()) {
593  if (query_desc_type == QueryDescriptionType::TableFunction) {
594  // Table functions output columns are always columnar
595  output_columnar_ = true;
596  }
597 }
598 
600  const int64_t min_val,
601  const int64_t max_val,
602  const bool has_nulls,
603  const std::vector<int8_t>& group_col_widths)
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)
611  , group_col_compact_width_(0)
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)
622  , threads_can_reuse_group_by_buffers_(false)
623  , force_4byte_float_(false)
624  , num_available_threads_(cpu_threads()) {}
625 
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 }
692 
693 std::unique_ptr<QueryExecutionContext> QueryMemoryDescriptor::getQueryExecutionContext(
694  const RelAlgExecutionUnit& ra_exe_unit,
695  const Executor* executor,
696  const ExecutorDeviceType device_type,
697  const ExecutorDispatchMode dispatch_mode,
698  const int device_id,
699  const shared::TableKey& outer_table_key,
700  const int64_t num_rows,
701  const std::vector<std::vector<const int8_t*>>& col_buffers,
702  const std::vector<std::vector<uint64_t>>& frag_offsets,
703  std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
704  const bool output_columnar,
705  const bool sort_on_gpu,
706  const size_t thread_idx,
707  RenderInfo* render_info) const {
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 }
729 
731  const RelAlgExecutionUnit& ra_exe_unit,
732  const std::vector<InputTableInfo>& query_infos,
733  const int8_t crt_min_byte_width) {
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 }
825 
828 }
829 
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 }
843 
845  return (interleaved_bins_on_gpu_ ? executor_->warpSize() : 1);
846 }
847 
850 }
851 
860 }
861 
867  const size_t num_entries_per_column) const {
868  return col_slot_context_.getTotalBytesOfColumnarBuffers(num_entries_per_column);
869 }
870 
881  const size_t projection_count) const {
882  constexpr size_t row_index_width = sizeof(int64_t);
883  return getTotalBytesOfColumnarBuffers(projection_count) +
884  row_index_width * projection_count;
885 }
886 
887 size_t QueryMemoryDescriptor::getColOnlyOffInBytes(const size_t col_idx) const {
888  return col_slot_context_.getColOnlyOffInBytes(col_idx);
889 }
890 
891 /*
892  * Returns the memory offset in bytes for a specific agg column in the output
893  * memory buffer. Depending on the query type, there may be some extra portion
894  * of memory prepended at the beginning of the buffer. A brief description of
895  * the memory layout is as follows:
896  * 1. projections: index column (64bit) + all target columns
897  * 2. group by: all group columns (64-bit each) + all agg columns
898  * 2a. if keyless, there is no prepending group column stored at the beginning
899  */
900 size_t QueryMemoryDescriptor::getColOffInBytes(const size_t col_idx) const {
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 }
938 
939 int64_t QueryMemoryDescriptor::getPaddedSlotBufferSize(const size_t slot_idx) const {
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 }
946 
947 /*
948  * Returns the memory offset for a particular group column in the prepended group
949  * columns portion of the memory.
950  */
952  const size_t group_idx) const {
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 }
964 
965 /*
966  * Returns total amount of memory prepended at the beginning of the output memory
967  * buffer.
968  */
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 }
979 
980 size_t QueryMemoryDescriptor::getColOffInBytesInNextBin(const size_t col_idx) const {
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 }
990 
991 size_t QueryMemoryDescriptor::getNextColOffInBytes(const int8_t* col_ptr,
992  const size_t bin,
993  const size_t col_idx) const {
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 }
1024 
1026  const size_t col_idx) const {
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 }
1041 
1043  const RelAlgExecutionUnit& ra_exe_unit,
1044  const unsigned thread_count,
1045  const ExecutorDeviceType device_type) const {
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 }
1053 
1067  const size_t entry_count) const {
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 }
1094 
1096  const ExecutorDeviceType device_type) const {
1097  return getBufferSizeBytes(device_type, entry_count_);
1098 }
1099 
1101  output_columnar_ = val;
1104  }
1105 }
1106 
1107 /*
1108  * Indicates the query types that are currently allowed to use the logical
1109  * sized columns instead of padded sized ones.
1110  */
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 }
1118 
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 }
1129 
1132  getGroupbyColCount() == 1);
1133 }
1134 
1137 }
1138 
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 }
1157 
1159  return device_type == ExecutorDeviceType::GPU && !render_output_ &&
1161 }
1162 
1164  return interleaved_bins_on_gpu_ && device_type == ExecutorDeviceType::GPU;
1165 }
1166 
1167 // TODO(Saman): an implementation detail, so move this out of QMD
1169  const ExecutorDeviceType device_type) const {
1170  if (device_type == ExecutorDeviceType::GPU) {
1171  return executor_->cudaMgr()->isArchVoltaOrGreaterForAll();
1172  }
1173  return false;
1174 }
1175 
1177  return col_slot_context_.getColCount();
1178 }
1179 
1182 }
1183 
1184 const int8_t QueryMemoryDescriptor::getPaddedSlotWidthBytes(const size_t slot_idx) const {
1185  return col_slot_context_.getSlotInfo(slot_idx).padded_size;
1186 }
1187 
1189  const int8_t bytes) {
1190  col_slot_context_.setPaddedSlotWidthBytes(slot_idx, bytes);
1191 }
1192 
1194  const size_t slot_idx) const {
1195  return col_slot_context_.getSlotInfo(slot_idx).logical_size;
1196 }
1197 
1199  const size_t col_idx) const {
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 }
1204 
1205 void QueryMemoryDescriptor::useConsistentSlotWidthSize(const int8_t slot_width_size) {
1206  col_slot_context_.setAllSlotsSize(slot_width_size);
1207 }
1208 
1210  // Note: Actual row size may include padding (see ResultSetBufferAccessors.h)
1212 }
1213 
1215  const int8_t actual_min_byte_width) const {
1216  return col_slot_context_.getMinPaddedByteSize(actual_min_byte_width);
1217 }
1218 
1220  const std::vector<std::tuple<int8_t, int8_t>>& slots_for_col) {
1221  col_slot_context_.addColumn(slots_for_col);
1222 }
1223 
1224 void QueryMemoryDescriptor::addColSlotInfoFlatBuffer(const int64_t flatbuffer_size) {
1225  col_slot_context_.addColumnFlatBuffer(flatbuffer_size);
1226 }
1227 
1230 }
1231 
1234 }
1235 
1240 }
1241 
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 }
1261 
1262 std::string QueryMemoryDescriptor::toString() const {
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 }
1287 
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 }
1311 
1312 std::vector<TargetInfo> target_exprs_to_infos(
1313  const std::vector<Analyzer::Expr*>& targets,
1315  std::vector<TargetInfo> target_infos;
1316  size_t index = 0;
1317  for (const auto target_expr : targets) {
1318  auto target = get_target_info(target_expr, g_bigint_count);
1319  if (query_mem_desc.getQueryDescriptionType() ==
1321  set_notnull(target, false);
1322  target.sql_type.set_notnull(false);
1323  }
1324  if (target.sql_type.supportsFlatBuffer()) {
1325  target.sql_type.setUsesFlatBuffer(
1326  query_mem_desc.checkSlotUsesFlatBufferFormat(index));
1327  }
1328  target_infos.push_back(target);
1329  index++;
1330  }
1331  return target_infos;
1332 }
1333 
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 }
1349 
1350 size_t QueryMemoryDescriptor::varlenOutputRowSizeToSlot(const size_t slot_idx) const {
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 }
1366 
1368  const RelAlgExecutionUnit& ra_exe_unit) const {
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 }
1377 
1379  const RelAlgExecutionUnit& ra_exe_unit) const {
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 }
size_t varlenOutputRowSizeToSlot(const size_t slot_idx) const
int8_t getMinPaddedByteSize(const int8_t actual_min_byte_width) const
std::vector< Analyzer::Expr * > target_exprs
static bool many_entries(const int64_t max_val, const int64_t min_val, const int64_t bucket)
void addColSlotInfoFlatBuffer(const int64_t flatbuffer_size)
int64_t getIntMin() const
bool canUsePerDeviceCardinality(const RelAlgExecutionUnit &ra_exe_unit) const
SQLAgg
Definition: sqldefs.h:73
#define CHECK_EQ(x, y)
Definition: Logger.h:301
size_t getBufferSizeBytes(const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const
bool g_enable_smem_group_by
static int64_t getBucketedCardinality(const ColRangeInfo &col_range_info)
void alignPaddedSlots(const bool sort_on_gpu)
std::vector< int64_t > target_expr_proj_indices(const RelAlgExecutionUnit &ra_exe_unit)
int8_t logical_size
size_t getTotalBytesOfColumnarProjections(const size_t projection_count) const
int64_t getTargetGroupbyIndex(const size_t target_idx) const
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)
std::string toString() const
bool g_enable_lazy_fetch
Definition: Execute.cpp:132
bool isLogicalSizedColumnsAllowed() const
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)
std::vector< int8_t > get_col_byte_widths(const T &col_expr_list)
int8_t pick_baseline_key_component_width(const ExpressionRange &range, const size_t group_col_width)
std::string join(T const &container, std::string const &delim)
std::vector< InputDescriptor > input_descs
#define UNREACHABLE()
Definition: Logger.h:338
void setOutputColumnar(const bool val)
#define CHECK_GE(x, y)
Definition: Logger.h:306
size_t getAllSlotsPaddedSize() const
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)
size_t getAllSlotsAlignedPaddedSize() const
size_t getNextColOffInBytes(const int8_t *col_ptr, const size_t bin, const size_t col_idx) const
size_t getEffectiveKeyWidth() const
bool use_streaming_top_n(const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
size_t g_streaming_topn_max
Definition: ResultSet.cpp:51
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
T visit(const Analyzer::Expr *expr) const
SortAlgorithm algorithm
#define CHECK_GT(x, y)
Definition: Logger.h:305
void setAllSlotsSize(const int8_t slot_width_size)
TargetInfo get_target_info(const Analyzer::Expr *target_expr, const bool bigint_count)
Definition: TargetInfo.h:92
ExecutorDeviceType
std::string to_string(char const *&&v)
std::optional< size_t > getMaxPerDeviceCardinality(const RelAlgExecutionUnit &ra_exe_unit) const
void useConsistentSlotWidthSize(const int8_t slot_width_size)
const SlotSize & getSlotInfo(const size_t slot_idx) const
std::vector< Analyzer::Expr * > target_exprs_union
constexpr double a
Definition: Utm.h:32
size_t getColOnlyOffInBytes(const size_t col_idx) const
ExecutorDispatchMode
size_t getColOnlyOffInBytes(const size_t slot_idx) const
const SQLTypeInfo get_compact_type(const TargetInfo &target)
bool is_varlen_projection(const Analyzer::Expr *target_expr, const SQLTypeInfo &ti)
bool g_enable_columnar_output
Definition: Execute.cpp:102
int8_t groupColWidth(const size_t key_idx) const
std::vector< std::pair< std::vector< size_t >, size_t > > per_device_cardinality
size_t get_bit_width(const SQLTypeInfo &ti)
void addColumnFlatBuffer(const int64_t flatbuffer_size)
std::vector< CountDistinctDescriptor > CountDistinctDescriptors
Definition: CountDistinct.h:34
size_t getCompactByteWidth() const
Provides column info and slot info for the output buffer and some metadata helpers.
size_t getGroupbyColCount() const
bool is_integer() const
Definition: sqltypes.h:565
const ColumnDescriptor * get_column_descriptor_maybe(const shared::ColumnKey &column_key)
Definition: Execute.h:241
const JoinQualsPerNestingLevel join_quals
bool lazyInitGroups(const ExecutorDeviceType) const
size_t targetGroupbyIndicesSize() const
std::optional< size_t > limit
size_t getPrependedGroupBufferSizeInBytes() const
std::list< Analyzer::OrderEntry > order_entries
size_t getTotalBytesOfColumnarBuffers() const
executor_(executor)
std::vector< int64_t > target_groupby_indices_
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)
bool g_bigint_count
CountDistinctDescriptors count_distinct_descriptors_
int32_t get_varno() const
Definition: Analyzer.h:288
bool is_valid_int32_range(const ExpressionRange &range)
void validate() const
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
ExpressionRange getExpressionRange(const Analyzer::BinOper *expr, const std::vector< InputTableInfo > &query_infos, const Executor *, boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>> simple_quals)
bool hasNulls() const
int64_t varlenOutputElementSize(const size_t slot_idx) const
int64_t getPaddedSlotBufferSize(const size_t slot_idx) const
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
QueryDescriptionType getQueryDescriptionType() const
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)
std::optional< size_t > varlenOutputBufferElemSize() const
void addColumn(const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)
#define CHECK_LT(x, y)
Definition: Logger.h:303
#define CHECK_LE(x, y)
Definition: Logger.h:304
size_t getNextColOffInBytesRowOnly(const int8_t *col_ptr, const size_t col_idx) const
const Expr * get_operand() const
Definition: Analyzer.h:384
QueryDescriptionType query_desc_type_
int8_t padded_size
Definition: sqldefs.h:78
int8_t updateActualMinByteWidth(const int8_t actual_min_byte_width) const
size_t getTotalBytesOfColumnarBuffers(const size_t entry_count) const
bool operator==(const QueryMemoryDescriptor &other) const
Descriptor for the result set buffer layout.
bool is_int_and_no_bigger_than(const SQLTypeInfo &ti, const size_t byte_width)
std::list< std::shared_ptr< Analyzer::Expr > > quals
ExpressionRangeType getType() const
size_t get_heap_size(const size_t row_size, const size_t n, const size_t thread_count)
int64_t getIntMax() const
bool isWarpSyncRequired(const ExecutorDeviceType) const
std::string toString() const
size_t getSlotCount() const
void setAllSlotsPaddedSizeToLogicalSize()
bool interleavedBins(const ExecutorDeviceType) const
bool g_enable_watchdog false
Definition: Execute.cpp:80
#define CHECK(condition)
Definition: Logger.h:291
#define DEBUG_TIMER(name)
Definition: Logger.h:412
size_t getColCount() const
std::vector< int8_t > group_col_widths_
#define EMPTY_KEY_32
QueryDescriptionType
Definition: Types.h:29
bool g_cluster
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)
std::vector< TargetInfo > target_exprs_to_infos(const std::vector< Analyzer::Expr * > &targets, const QueryMemoryDescriptor &query_mem_desc)
const std::vector< size_t > & getSlotsForCol(const size_t col_idx) const
std::string queryDescTypeToString() const
bool any_of(std::vector< Analyzer::Expr * > const &target_exprs)
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
constexpr double n
Definition: Utm.h:38
void addColSlotInfo(const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)
void setAllUnsetSlotsPaddedSize(const int8_t padded_size)
int64_t getFlatBufferSize(const size_t slot_idx) const
int cpu_threads()
Definition: thread_count.h:25
const int8_t getSlotIndexForSingleSlotCol(const size_t col_idx) const
bool checkSlotUsesFlatBufferFormat(const size_t slot_idx) const
const int8_t getLogicalSlotWidthBytes(const size_t slot_idx) const
Definition: sqldefs.h:74
size_t getColOffInBytes(const size_t col_idx) const
size_t getColOffInBytesInNextBin(const size_t col_idx) 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
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)
int8_t pick_baseline_key_width(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Executor *executor)
std::string reductionKey() const
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals
void set_notnull(TargetInfo &target, const bool not_null)
int32_t getTargetIdxForKey() const
size_t getPrependedGroupColOffInBytes(const size_t group_idx) const