OmniSciDB  cecceef8da
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Executor::ExecutionDispatch Class Reference
+ Collaboration diagram for Executor::ExecutionDispatch:

Public Member Functions

 ExecutionDispatch (Executor *executor, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Catalog_Namespace::Catalog &cat, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, RenderInfo *render_info)
 
 ExecutionDispatch (const ExecutionDispatch &)=delete
 
ExecutionDispatchoperator= (const ExecutionDispatch &)=delete
 
 ExecutionDispatch (ExecutionDispatch &&)=delete
 
ExecutionDispatchoperator= (ExecutionDispatch &&)=delete
 
std::tuple
< QueryCompilationDescriptorOwned,
QueryMemoryDescriptorOwned
compile (const size_t max_groups_buffer_entry_guess, const int8_t crt_min_byte_width, const CompilationOptions &co, const ExecutionOptions &eo, const ColumnFetcher &column_fetcher, const bool has_cardinality_estimation)
 
void run (const ExecutorDeviceType chosen_device_type, int chosen_device_id, const ExecutionOptions &eo, const ColumnFetcher &column_fetcher, const QueryCompilationDescriptor &query_comp_desc, const QueryMemoryDescriptor &query_mem_desc, const FragmentsList &frag_ids, const ExecutorDispatchMode kernel_dispatch_mode, const int64_t rowid_lookup_key)
 
const RelAlgExecutionUnitgetExecutionUnit () const
 
const std::vector< uint64_t > & getFragOffsets () const
 
std::vector< std::pair
< ResultSetPtr, std::vector
< size_t > > > & 
getFragmentResults ()
 

Private Member Functions

void runImpl (const ExecutorDeviceType chosen_device_type, int chosen_device_id, const ExecutionOptions &eo, const ColumnFetcher &column_fetcher, const QueryCompilationDescriptor &query_comp_desc, const QueryMemoryDescriptor &query_mem_desc, const FragmentsList &frag_list, const ExecutorDispatchMode kernel_dispatch_mode, const int64_t rowid_lookup_key)
 

Private Attributes

Executorexecutor_
 
const RelAlgExecutionUnitra_exe_unit_
 
const std::vector
< InputTableInfo > & 
query_infos_
 
const Catalog_Namespace::Catalogcat_
 
std::vector< uint64_t > all_frag_row_offsets_
 
std::mutex all_frag_row_offsets_mutex_
 
const std::shared_ptr
< RowSetMemoryOwner
row_set_mem_owner_
 
RenderInforender_info_
 
std::vector< std::pair
< ResultSetPtr, std::vector
< size_t > > > 
all_fragment_results_
 
std::atomic_flag dynamic_watchdog_set_ = ATOMIC_FLAG_INIT
 

Static Private Attributes

static std::mutex reduce_mutex_
 

Friends

class QueryCompilationDescriptor
 

Detailed Description

Definition at line 467 of file Execute.h.

Constructor & Destructor Documentation

Executor::ExecutionDispatch::ExecutionDispatch ( Executor executor,
const RelAlgExecutionUnit ra_exe_unit,
const std::vector< InputTableInfo > &  query_infos,
const Catalog_Namespace::Catalog cat,
const std::shared_ptr< RowSetMemoryOwner row_set_mem_owner,
RenderInfo render_info 
)

Definition at line 268 of file ExecutionDispatch.cpp.

References all_fragment_results_, and query_infos_.

275  : executor_(executor)
276  , ra_exe_unit_(ra_exe_unit)
277  , query_infos_(query_infos)
278  , cat_(cat)
279  , row_set_mem_owner_(row_set_mem_owner)
280  , render_info_(render_info) {
281  all_fragment_results_.reserve(query_infos_.front().info.fragments.size());
282 }
const Catalog_Namespace::Catalog & cat_
Definition: Execute.h:472
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:471
const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
Definition: Execute.h:475
std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > all_fragment_results_
Definition: Execute.h:477
RenderInfo * render_info_
Definition: Execute.h:476
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:470
Executor::ExecutionDispatch::ExecutionDispatch ( const ExecutionDispatch )
delete
Executor::ExecutionDispatch::ExecutionDispatch ( ExecutionDispatch &&  )
delete

Member Function Documentation

std::tuple< QueryCompilationDescriptorOwned, QueryMemoryDescriptorOwned > Executor::ExecutionDispatch::compile ( const size_t  max_groups_buffer_entry_guess,
const int8_t  crt_min_byte_width,
const CompilationOptions co,
const ExecutionOptions eo,
const ColumnFetcher column_fetcher,
const bool  has_cardinality_estimation 
)

Definition at line 285 of file ExecutionDispatch.cpp.

References CPU, CompilationOptions::device_type, GPU, query_mem_desc, and UNREACHABLE.

Referenced by Executor::executeUpdate(), Executor::executeWorkUnitImpl(), and Executor::executeWorkUnitPerFragment().

290  {
291  auto query_comp_desc = std::make_unique<QueryCompilationDescriptor>();
292  std::unique_ptr<QueryMemoryDescriptor> query_mem_desc;
293 
294  switch (co.device_type) {
296  query_mem_desc = query_comp_desc->compile(max_groups_buffer_entry_guess,
297  crt_min_byte_width,
298  has_cardinality_estimation,
299  ra_exe_unit_,
300  query_infos_,
301  column_fetcher,
302  co,
303  eo,
304  render_info_,
305  executor_);
306  break;
307  }
309  query_mem_desc = query_comp_desc->compile(max_groups_buffer_entry_guess,
310  crt_min_byte_width,
311  has_cardinality_estimation,
312  ra_exe_unit_,
313  query_infos_,
314  column_fetcher,
315  co,
316  eo,
317  render_info_,
318  executor_);
319  break;
320  }
321  default:
322  UNREACHABLE();
323  }
324 
325  return std::make_tuple(std::move(query_comp_desc), std::move(query_mem_desc));
326 }
#define UNREACHABLE()
Definition: Logger.h:241
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:471
ExecutorDeviceType device_type
RenderInfo * render_info_
Definition: Execute.h:476
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:470

+ Here is the caller graph for this function:

const RelAlgExecutionUnit & Executor::ExecutionDispatch::getExecutionUnit ( ) const

Definition at line 371 of file ExecutionDispatch.cpp.

Referenced by Executor::collectAllDeviceResults(), Executor::collectAllDeviceShardedTopResults(), Executor::dispatchFragments(), and Executor::resultsUnion().

371  {
372  return ra_exe_unit_;
373 }
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:470

+ Here is the caller graph for this function:

std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > & Executor::ExecutionDispatch::getFragmentResults ( )

Definition at line 389 of file ExecutionDispatch.cpp.

Referenced by Executor::collectAllDeviceResults(), Executor::collectAllDeviceShardedTopResults(), Executor::executeUpdate(), and Executor::resultsUnion().

389  {
390  return all_fragment_results_;
391 }
std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > all_fragment_results_
Definition: Execute.h:477

+ Here is the caller graph for this function:

const std::vector< uint64_t > & Executor::ExecutionDispatch::getFragOffsets ( ) const

Definition at line 375 of file ExecutionDispatch.cpp.

Referenced by Executor::dispatchFragments(), and runImpl().

375  {
376  std::lock_guard<std::mutex> lock(all_frag_row_offsets_mutex_);
377  if (all_frag_row_offsets_.empty()) {
378  all_frag_row_offsets_.resize(query_infos_.front().info.fragments.size() + 1);
379  for (size_t i = 1; i <= query_infos_.front().info.fragments.size(); ++i) {
381  all_frag_row_offsets_[i - 1] +
382  query_infos_.front().info.fragments[i - 1].getNumTuples();
383  }
384  }
385  return all_frag_row_offsets_;
386 }
std::vector< uint64_t > all_frag_row_offsets_
Definition: Execute.h:473
std::mutex all_frag_row_offsets_mutex_
Definition: Execute.h:474
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:471

+ Here is the caller graph for this function:

ExecutionDispatch& Executor::ExecutionDispatch::operator= ( const ExecutionDispatch )
delete
ExecutionDispatch& Executor::ExecutionDispatch::operator= ( ExecutionDispatch &&  )
delete
void Executor::ExecutionDispatch::run ( const ExecutorDeviceType  chosen_device_type,
int  chosen_device_id,
const ExecutionOptions eo,
const ColumnFetcher column_fetcher,
const QueryCompilationDescriptor query_comp_desc,
const QueryMemoryDescriptor query_mem_desc,
const FragmentsList frag_ids,
const ExecutorDispatchMode  kernel_dispatch_mode,
const int64_t  rowid_lookup_key 
)

Definition at line 328 of file ExecutionDispatch.cpp.

References Executor::ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED, Executor::ERR_OUT_OF_CPU_MEM, Executor::ERR_OUT_OF_GPU_MEM, Executor::ERR_OUT_OF_RENDER_MEM, Executor::ERR_STRING_CONST_IN_RESULTSET, Executor::ERR_TOO_MANY_LITERALS, QueryMemoryDescriptor::getQueryDescriptionType(), and MultifragmentKernel.

Referenced by Executor::executeUpdate(), Executor::executeWorkUnitImpl(), and Executor::executeWorkUnitPerFragment().

336  {
337  try {
338  runImpl(chosen_device_type,
339  chosen_device_id,
340  eo,
341  column_fetcher,
342  query_comp_desc,
343  query_mem_desc,
344  frag_list,
345  kernel_dispatch_mode,
346  rowid_lookup_key);
347  } catch (const std::bad_alloc& e) {
348  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM, e.what());
349  } catch (const OutOfHostMemory& e) {
350  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM, e.what());
351  } catch (const OutOfRenderMemory& e) {
353  } catch (const OutOfMemory& e) {
354  throw QueryExecutionError(
356  e.what(),
358  query_mem_desc.getQueryDescriptionType(),
359  kernel_dispatch_mode == ExecutorDispatchMode::MultifragmentKernel});
360  } catch (const ColumnarConversionNotSupported& e) {
362  } catch (const TooManyLiterals& e) {
364  } catch (const SringConstInResultSet& e) {
366  } catch (const QueryExecutionError& e) {
367  throw e;
368  }
369 }
static const int32_t ERR_TOO_MANY_LITERALS
Definition: Execute.h:971
static const int32_t ERR_STRING_CONST_IN_RESULTSET
Definition: Execute.h:972
static const int32_t ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED
Definition: Execute.h:970
static const int32_t ERR_OUT_OF_RENDER_MEM
Definition: Execute.h:964
static const int32_t ERR_OUT_OF_GPU_MEM
Definition: Execute.h:961
QueryDescriptionType getQueryDescriptionType() const
void runImpl(const ExecutorDeviceType chosen_device_type, int chosen_device_id, const ExecutionOptions &eo, const ColumnFetcher &column_fetcher, const QueryCompilationDescriptor &query_comp_desc, const QueryMemoryDescriptor &query_mem_desc, const FragmentsList &frag_list, const ExecutorDispatchMode kernel_dispatch_mode, const int64_t rowid_lookup_key)
static const int32_t ERR_OUT_OF_CPU_MEM
Definition: Execute.h:965

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void Executor::ExecutionDispatch::runImpl ( const ExecutorDeviceType  chosen_device_type,
int  chosen_device_id,
const ExecutionOptions eo,
const ColumnFetcher column_fetcher,
const QueryCompilationDescriptor query_comp_desc,
const QueryMemoryDescriptor query_mem_desc,
const FragmentsList frag_list,
const ExecutorDispatchMode  kernel_dispatch_mode,
const int64_t  rowid_lookup_key 
)
private

Definition at line 67 of file ExecutionDispatch.cpp.

References all_fragment_results_, cat_, CHECK(), CHECK_EQ, CHECK_GE, CHECK_GT, CHECK_LT, FetchResult::col_buffers, QueryFragmentDescriptor::computeAllTablesFragments(), CPU, Data_Namespace::CPU_LEVEL, dynamic_watchdog_init(), dynamic_watchdog_set_, ExecutionOptions::dynamic_watchdog_time_limit, Executor::ERR_OUT_OF_CPU_MEM, Executor::ERR_OUT_OF_GPU_MEM, executor_, ExecutionOptions::executor_type, Extern, FetchResult::frag_offsets, QueryCompilationDescriptor::getCompilationResult(), Catalog_Namespace::Catalog::getDataMgr(), getFragOffsets(), QueryMemoryDescriptor::getQueryDescriptionType(), QueryMemoryDescriptor::getQueryExecutionContext(), GPU, Data_Namespace::GPU_LEVEL, RelAlgExecutionUnit::groupby_exprs, QueryCompilationDescriptor::hoistLiterals(), logger::INFO, RelAlgExecutionUnit::input_descs, RenderInfo::isPotentialInSituRender(), KernelPerFragment, LOG, Executor::max_gpu_count, MultifragmentKernel, Native, anonymous_namespace{ExecutionDispatch.cpp}::need_to_hold_chunk(), anonymous_namespace{ExecutionDispatch.cpp}::needs_skip_result(), FetchResult::num_rows, Executor::CompilationResult::output_columnar, Projection, anonymous_namespace{ExecutionDispatch.cpp}::query_has_inner_join(), query_infos_, query_mem_desc, ra_exe_unit_, reduce_mutex_, render_info_, row_set_mem_owner_, run_query_external(), RelAlgExecutionUnit::scan_limit, serialize_to_sql(), QueryMemoryDescriptor::sortOnGpu(), RelAlgExecutionUnit::target_exprs, target_exprs_to_infos(), to_string(), and ExecutionOptions::with_dynamic_watchdog.

76  {
77  const auto memory_level = chosen_device_type == ExecutorDeviceType::GPU
80  const int outer_table_id = ra_exe_unit_.input_descs[0].getTableId();
81  CHECK_GE(frag_list.size(), size_t(1));
82  CHECK_EQ(frag_list[0].table_id, outer_table_id);
83  const auto& outer_tab_frag_ids = frag_list[0].fragment_ids;
84  CHECK_GE(chosen_device_id, 0);
85  CHECK_LT(chosen_device_id, max_gpu_count);
86  // need to own them while query executes
87  auto chunk_iterators_ptr = std::make_shared<std::list<ChunkIter>>();
88  std::list<std::shared_ptr<Chunk_NS::Chunk>> chunks;
89  std::unique_ptr<std::lock_guard<std::mutex>> gpu_lock;
90  if (chosen_device_type == ExecutorDeviceType::GPU) {
91  gpu_lock.reset(
92  new std::lock_guard<std::mutex>(executor_->gpu_exec_mutex_[chosen_device_id]));
93  }
94  FetchResult fetch_result;
95  try {
96  std::map<int, const TableFragments*> all_tables_fragments;
98  all_tables_fragments, ra_exe_unit_, query_infos_);
99 
100  fetch_result = executor_->fetchChunks(column_fetcher,
101  ra_exe_unit_,
102  chosen_device_id,
103  memory_level,
104  all_tables_fragments,
105  frag_list,
106  cat_,
107  *chunk_iterators_ptr,
108  chunks);
109  if (fetch_result.num_rows.empty()) {
110  return;
111  }
112  if (eo.with_dynamic_watchdog &&
113  !dynamic_watchdog_set_.test_and_set(std::memory_order_acquire)) {
115  auto cycle_budget = dynamic_watchdog_init(eo.dynamic_watchdog_time_limit);
116  LOG(INFO) << "Dynamic Watchdog budget: CPU: "
118  << std::to_string(cycle_budget) << " cycles";
119  }
120  } catch (const OutOfMemory&) {
121  throw QueryExecutionError(
125  query_mem_desc.getQueryDescriptionType(),
126  kernel_dispatch_mode == ExecutorDispatchMode::MultifragmentKernel});
127  return;
128  }
129 
131  if (ra_exe_unit_.input_descs.size() > 1) {
132  throw std::runtime_error("Joins not supported through external execution");
133  }
134  const auto query = serialize_to_sql(&ra_exe_unit_, executor_->getCatalog());
135  GroupByAndAggregate group_by_and_aggregate(executor_,
137  ra_exe_unit_,
138  query_infos_,
139  executor_->row_set_mem_owner_);
140  const auto query_mem_desc =
141  group_by_and_aggregate.initQueryMemoryDescriptor(false, 0, 8, nullptr, false);
142  auto device_results = run_query_external(
143  query,
144  fetch_result,
145  executor_->plan_state_.get(),
149  executor_});
150  std::lock_guard<std::mutex> lock(reduce_mutex_);
151  all_fragment_results_.emplace_back(std::move(device_results), outer_tab_frag_ids);
152  return;
153  }
154  const CompilationResult& compilation_result = query_comp_desc.getCompilationResult();
155  std::unique_ptr<QueryExecutionContext> query_exe_context_owned;
156  const bool do_render = render_info_ && render_info_->isPotentialInSituRender();
157 
158  int64_t total_num_input_rows{-1};
159  if (kernel_dispatch_mode == ExecutorDispatchMode::KernelPerFragment &&
161  total_num_input_rows = 0;
162  std::for_each(fetch_result.num_rows.begin(),
163  fetch_result.num_rows.end(),
164  [&total_num_input_rows](const std::vector<int64_t>& frag_row_count) {
165  total_num_input_rows = std::accumulate(frag_row_count.begin(),
166  frag_row_count.end(),
167  total_num_input_rows);
168  });
169  // TODO(adb): we may want to take this early out for all queries, but we are most
170  // likely to see this query pattern on the kernel per fragment path (e.g. with HAVING
171  // 0=1)
172  if (total_num_input_rows == 0) {
173  return;
174  }
175 
177  total_num_input_rows *= ra_exe_unit_.input_descs.size();
178  }
179  }
180 
182  try {
183  query_exe_context_owned =
184  query_mem_desc.getQueryExecutionContext(ra_exe_unit_,
185  executor_,
186  chosen_device_type,
187  kernel_dispatch_mode,
188  chosen_device_id,
189  total_num_input_rows,
190  fetch_result.col_buffers,
191  fetch_result.frag_offsets,
193  compilation_result.output_columnar,
194  query_mem_desc.sortOnGpu(),
195  do_render ? render_info_ : nullptr);
196  } catch (const OutOfHostMemory& e) {
197  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM);
198  }
199  }
200  QueryExecutionContext* query_exe_context{query_exe_context_owned.get()};
201  CHECK(query_exe_context);
202  int32_t err{0};
203  uint32_t start_rowid{0};
204  if (rowid_lookup_key >= 0) {
205  if (!frag_list.empty()) {
206  const auto& all_frag_row_offsets = getFragOffsets();
207  start_rowid = rowid_lookup_key -
208  all_frag_row_offsets[frag_list.begin()->fragment_ids.front()];
209  }
210  }
211 
212  ResultSetPtr device_results;
213  if (ra_exe_unit_.groupby_exprs.empty()) {
214  err = executor_->executePlanWithoutGroupBy(ra_exe_unit_,
215  compilation_result,
216  query_comp_desc.hoistLiterals(),
217  device_results,
219  chosen_device_type,
220  fetch_result.col_buffers,
221  query_exe_context,
222  fetch_result.num_rows,
223  fetch_result.frag_offsets,
224  &cat_.getDataMgr(),
225  chosen_device_id,
226  start_rowid,
227  ra_exe_unit_.input_descs.size(),
228  do_render ? render_info_ : nullptr);
229  } else {
230  err = executor_->executePlanWithGroupBy(ra_exe_unit_,
231  compilation_result,
232  query_comp_desc.hoistLiterals(),
233  device_results,
234  chosen_device_type,
235  fetch_result.col_buffers,
236  outer_tab_frag_ids,
237  query_exe_context,
238  fetch_result.num_rows,
239  fetch_result.frag_offsets,
240  &cat_.getDataMgr(),
241  chosen_device_id,
243  start_rowid,
244  ra_exe_unit_.input_descs.size(),
245  do_render ? render_info_ : nullptr);
246  }
247  if (device_results) {
248  std::list<std::shared_ptr<Chunk_NS::Chunk>> chunks_to_hold;
249  for (const auto chunk : chunks) {
250  if (need_to_hold_chunk(chunk.get(), ra_exe_unit_)) {
251  chunks_to_hold.push_back(chunk);
252  }
253  }
254  device_results->holdChunks(chunks_to_hold);
255  device_results->holdChunkIterators(chunk_iterators_ptr);
256  }
257  if (err) {
258  throw QueryExecutionError(err);
259  }
260  {
261  std::lock_guard<std::mutex> lock(reduce_mutex_);
262  if (!needs_skip_result(device_results)) {
263  all_fragment_results_.emplace_back(std::move(device_results), outer_tab_frag_ids);
264  }
265  }
266 }
std::vector< Analyzer::Expr * > target_exprs
#define CHECK_EQ(x, y)
Definition: Logger.h:205
std::unique_ptr< QueryExecutionContext > getQueryExecutionContext(const RelAlgExecutionUnit &, const Executor *executor, const ExecutorDeviceType device_type, const ExecutorDispatchMode dispatch_mode, const int device_id, 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, RenderInfo *) const
Data_Namespace::DataMgr & getDataMgr() const
Definition: Catalog.h:181
static const int max_gpu_count
Definition: Execute.h:921
#define LOG(tag)
Definition: Logger.h:188
bool needs_skip_result(const ResultSetPtr &res)
static std::mutex reduce_mutex_
Definition: Execute.h:479
#define CHECK_GE(x, y)
Definition: Logger.h:210
std::shared_ptr< ResultSet > ResultSetPtr
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
std::unique_ptr< ResultSet > run_query_external(const ExecutionUnitSql &sql, const FetchResult &fetch_result, const PlanState *plan_state, const ExternalQueryOutputSpec &output_spec)
const std::vector< InputDescriptor > input_descs
#define CHECK_GT(x, y)
Definition: Logger.h:209
std::string to_string(char const *&&v)
CHECK(cgen_state)
ExecutorType executor_type
const Catalog_Namespace::Catalog & cat_
Definition: Execute.h:472
const bool with_dynamic_watchdog
const std::vector< uint64_t > & getFragOffsets() const
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:471
const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
Definition: Execute.h:475
uint64_t dynamic_watchdog_init(unsigned ms_budget)
static const int32_t ERR_OUT_OF_GPU_MEM
Definition: Execute.h:961
QueryDescriptionType getQueryDescriptionType() const
#define CHECK_LT(x, y)
Definition: Logger.h:207
bool query_has_inner_join(const RelAlgExecutionUnit &ra_exe_unit)
std::vector< std::vector< const int8_t * > > col_buffers
Definition: Execute.h:330
bool need_to_hold_chunk(const Chunk_NS::Chunk *chunk, const RelAlgExecutionUnit &ra_exe_unit)
bool isPotentialInSituRender() const
Definition: RenderInfo.cpp:61
std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > all_fragment_results_
Definition: Execute.h:477
std::vector< std::vector< int64_t > > num_rows
Definition: Execute.h:331
std::vector< TargetInfo > target_exprs_to_infos(const std::vector< Analyzer::Expr * > &targets, const QueryMemoryDescriptor &query_mem_desc)
std::atomic_flag dynamic_watchdog_set_
Definition: Execute.h:478
std::vector< std::vector< uint64_t > > frag_offsets
Definition: Execute.h:332
RenderInfo * render_info_
Definition: Execute.h:476
ExecutionUnitSql serialize_to_sql(const RelAlgExecutionUnit *ra_exe_unit, const Catalog_Namespace::Catalog *catalog)
const unsigned dynamic_watchdog_time_limit
static const int32_t ERR_OUT_OF_CPU_MEM
Definition: Execute.h:965
static void computeAllTablesFragments(std::map< int, const TableFragments * > &all_tables_fragments, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos)
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:470

+ Here is the call graph for this function:

Friends And Related Function Documentation

friend class QueryCompilationDescriptor
friend

Definition at line 531 of file Execute.h.

Member Data Documentation

std::vector<uint64_t> Executor::ExecutionDispatch::all_frag_row_offsets_
mutableprivate

Definition at line 473 of file Execute.h.

std::mutex Executor::ExecutionDispatch::all_frag_row_offsets_mutex_
mutableprivate

Definition at line 474 of file Execute.h.

std::vector<std::pair<ResultSetPtr, std::vector<size_t> > > Executor::ExecutionDispatch::all_fragment_results_
private

Definition at line 477 of file Execute.h.

Referenced by ExecutionDispatch(), and runImpl().

const Catalog_Namespace::Catalog& Executor::ExecutionDispatch::cat_
private

Definition at line 472 of file Execute.h.

Referenced by runImpl().

std::atomic_flag Executor::ExecutionDispatch::dynamic_watchdog_set_ = ATOMIC_FLAG_INIT
private

Definition at line 478 of file Execute.h.

Referenced by runImpl().

Executor* Executor::ExecutionDispatch::executor_
private

Definition at line 469 of file Execute.h.

Referenced by runImpl().

const std::vector<InputTableInfo>& Executor::ExecutionDispatch::query_infos_
private

Definition at line 471 of file Execute.h.

Referenced by ExecutionDispatch(), and runImpl().

const RelAlgExecutionUnit& Executor::ExecutionDispatch::ra_exe_unit_
private

Definition at line 470 of file Execute.h.

Referenced by runImpl().

std::mutex Executor::ExecutionDispatch::reduce_mutex_
staticprivate

Definition at line 479 of file Execute.h.

Referenced by runImpl().

RenderInfo* Executor::ExecutionDispatch::render_info_
private

Definition at line 476 of file Execute.h.

Referenced by runImpl().

const std::shared_ptr<RowSetMemoryOwner> Executor::ExecutionDispatch::row_set_mem_owner_
private

Definition at line 475 of file Execute.h.

Referenced by runImpl().


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