OmniSciDB  1dac507f6e
 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 537 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 240 of file ExecutionDispatch.cpp.

References all_fragment_results_, and query_infos_.

247  : executor_(executor)
248  , ra_exe_unit_(ra_exe_unit)
249  , query_infos_(query_infos)
250  , cat_(cat)
251  , row_set_mem_owner_(row_set_mem_owner)
252  , render_info_(render_info) {
253  all_fragment_results_.reserve(query_infos_.front().info.fragments.size());
254 }
const Catalog_Namespace::Catalog & cat_
Definition: Execute.h:542
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:541
const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
Definition: Execute.h:545
std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > all_fragment_results_
Definition: Execute.h:547
RenderInfo * render_info_
Definition: Execute.h:546
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:540
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 257 of file ExecutionDispatch.cpp.

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

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

262  {
263  auto query_comp_desc = std::make_unique<QueryCompilationDescriptor>();
264  std::unique_ptr<QueryMemoryDescriptor> query_mem_desc;
265 
266  switch (co.device_type_) {
268  query_mem_desc = query_comp_desc->compile(max_groups_buffer_entry_guess,
269  crt_min_byte_width,
270  has_cardinality_estimation,
271  ra_exe_unit_,
272  query_infos_,
273  column_fetcher,
274  co,
275  eo,
276  render_info_,
277  executor_);
278  break;
279  }
281  query_mem_desc = query_comp_desc->compile(max_groups_buffer_entry_guess,
282  crt_min_byte_width,
283  has_cardinality_estimation,
284  ra_exe_unit_,
285  query_infos_,
286  column_fetcher,
287  co,
288  eo,
289  render_info_,
290  executor_);
291  break;
292  }
293  default:
294  UNREACHABLE();
295  }
296 
297  return std::make_tuple(std::move(query_comp_desc), std::move(query_mem_desc));
298 }
#define UNREACHABLE()
Definition: Logger.h:234
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:541
ExecutorDeviceType device_type_
RenderInfo * render_info_
Definition: Execute.h:546
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:540

+ Here is the caller graph for this function:

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

Definition at line 343 of file ExecutionDispatch.cpp.

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

343  {
344  return ra_exe_unit_;
345 }
const RelAlgExecutionUnit & ra_exe_unit_
Definition: Execute.h:540

+ Here is the caller graph for this function:

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

Definition at line 361 of file ExecutionDispatch.cpp.

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

361  {
362  return all_fragment_results_;
363 }
std::vector< std::pair< ResultSetPtr, std::vector< size_t > > > all_fragment_results_
Definition: Execute.h:547

+ Here is the caller graph for this function:

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

Definition at line 347 of file ExecutionDispatch.cpp.

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

347  {
348  std::lock_guard<std::mutex> lock(all_frag_row_offsets_mutex_);
349  if (all_frag_row_offsets_.empty()) {
350  all_frag_row_offsets_.resize(query_infos_.front().info.fragments.size() + 1);
351  for (size_t i = 1; i <= query_infos_.front().info.fragments.size(); ++i) {
353  all_frag_row_offsets_[i - 1] +
354  query_infos_.front().info.fragments[i - 1].getNumTuples();
355  }
356  }
357  return all_frag_row_offsets_;
358 }
std::vector< uint64_t > all_frag_row_offsets_
Definition: Execute.h:543
std::mutex all_frag_row_offsets_mutex_
Definition: Execute.h:544
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:541

+ 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 300 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().

308  {
309  try {
310  runImpl(chosen_device_type,
311  chosen_device_id,
312  eo,
313  column_fetcher,
314  query_comp_desc,
315  query_mem_desc,
316  frag_list,
317  kernel_dispatch_mode,
318  rowid_lookup_key);
319  } catch (const std::bad_alloc& e) {
320  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM, e.what());
321  } catch (const OutOfHostMemory& e) {
322  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM, e.what());
323  } catch (const OutOfRenderMemory& e) {
325  } catch (const OutOfMemory& e) {
326  throw QueryExecutionError(
328  e.what(),
330  query_mem_desc.getQueryDescriptionType(),
331  kernel_dispatch_mode == ExecutorDispatchMode::MultifragmentKernel});
332  } catch (const ColumnarConversionNotSupported& e) {
334  } catch (const TooManyLiterals& e) {
336  } catch (const SringConstInResultSet& e) {
338  } catch (const QueryExecutionError& e) {
339  throw e;
340  }
341 }
static const int32_t ERR_TOO_MANY_LITERALS
Definition: Execute.h:1044
static const int32_t ERR_STRING_CONST_IN_RESULTSET
Definition: Execute.h:1045
static const int32_t ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED
Definition: Execute.h:1043
static const int32_t ERR_OUT_OF_RENDER_MEM
Definition: Execute.h:1037
static const int32_t ERR_OUT_OF_GPU_MEM
Definition: Execute.h:1034
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:1038

+ 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 65 of file ExecutionDispatch.cpp.

References all_fragment_results_, cat_, CHECK(), CHECK_EQ, CHECK_GE, CHECK_GT, CHECK_LT, Executor::FetchResult::col_buffers, QueryFragmentDescriptor::computeAllTablesFragments(), 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_, Executor::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, anonymous_namespace{ExecutionDispatch.cpp}::need_to_hold_chunk(), anonymous_namespace{ExecutionDispatch.cpp}::needs_skip_result(), Executor::FetchResult::num_rows, Executor::CompilationResult::output_columnar, Projection, anonymous_namespace{ExecutionDispatch.cpp}::query_has_inner_join(), query_infos_, ra_exe_unit_, reduce_mutex_, render_info_, row_set_mem_owner_, RelAlgExecutionUnit::scan_limit, QueryMemoryDescriptor::sortOnGpu(), RelAlgExecutionUnit::target_exprs, to_string(), and ExecutionOptions::with_dynamic_watchdog.

74  {
75  const auto memory_level = chosen_device_type == ExecutorDeviceType::GPU
78  const int outer_table_id = ra_exe_unit_.input_descs[0].getTableId();
79  CHECK_GE(frag_list.size(), size_t(1));
80  CHECK_EQ(frag_list[0].table_id, outer_table_id);
81  const auto& outer_tab_frag_ids = frag_list[0].fragment_ids;
82  CHECK_GE(chosen_device_id, 0);
83  CHECK_LT(chosen_device_id, max_gpu_count);
84  // need to own them while query executes
85  auto chunk_iterators_ptr = std::make_shared<std::list<ChunkIter>>();
86  std::list<std::shared_ptr<Chunk_NS::Chunk>> chunks;
87  std::unique_ptr<std::lock_guard<std::mutex>> gpu_lock;
88  if (chosen_device_type == ExecutorDeviceType::GPU) {
89  gpu_lock.reset(
90  new std::lock_guard<std::mutex>(executor_->gpu_exec_mutex_[chosen_device_id]));
91  }
92  FetchResult fetch_result;
93  try {
94  std::map<int, const TableFragments*> all_tables_fragments;
96  all_tables_fragments, ra_exe_unit_, query_infos_);
97 
98  fetch_result = executor_->fetchChunks(column_fetcher,
100  chosen_device_id,
101  memory_level,
102  all_tables_fragments,
103  frag_list,
104  cat_,
105  *chunk_iterators_ptr,
106  chunks);
107  if (fetch_result.num_rows.empty()) {
108  return;
109  }
110  if (eo.with_dynamic_watchdog &&
111  !dynamic_watchdog_set_.test_and_set(std::memory_order_acquire)) {
113  auto cycle_budget = dynamic_watchdog_init(eo.dynamic_watchdog_time_limit);
114  LOG(INFO) << "Dynamic Watchdog budget: CPU: "
116  << std::to_string(cycle_budget) << " cycles";
117  }
118  } catch (const OutOfMemory&) {
119  throw QueryExecutionError(
123  query_mem_desc.getQueryDescriptionType(),
124  kernel_dispatch_mode == ExecutorDispatchMode::MultifragmentKernel});
125  return;
126  }
127 
128  const CompilationResult& compilation_result = query_comp_desc.getCompilationResult();
129  std::unique_ptr<QueryExecutionContext> query_exe_context_owned;
130  const bool do_render = render_info_ && render_info_->isPotentialInSituRender();
131 
132  int64_t total_num_input_rows{-1};
133  if (kernel_dispatch_mode == ExecutorDispatchMode::KernelPerFragment &&
135  total_num_input_rows = 0;
136  std::for_each(fetch_result.num_rows.begin(),
137  fetch_result.num_rows.end(),
138  [&total_num_input_rows](const std::vector<int64_t>& frag_row_count) {
139  total_num_input_rows = std::accumulate(frag_row_count.begin(),
140  frag_row_count.end(),
141  total_num_input_rows);
142  });
143  // TODO(adb): we may want to take this early out for all queries, but we are most
144  // likely to see this query pattern on the kernel per fragment path (e.g. with HAVING
145  // 0=1)
146  if (total_num_input_rows == 0) {
147  return;
148  }
149 
151  total_num_input_rows *= ra_exe_unit_.input_descs.size();
152  }
153  }
154 
155  try {
156  query_exe_context_owned =
157  query_mem_desc.getQueryExecutionContext(ra_exe_unit_,
158  executor_,
159  chosen_device_type,
160  kernel_dispatch_mode,
161  chosen_device_id,
162  total_num_input_rows,
163  fetch_result.col_buffers,
164  fetch_result.frag_offsets,
166  compilation_result.output_columnar,
167  query_mem_desc.sortOnGpu(),
168  do_render ? render_info_ : nullptr);
169  } catch (const OutOfHostMemory& e) {
170  throw QueryExecutionError(ERR_OUT_OF_CPU_MEM);
171  }
172  QueryExecutionContext* query_exe_context{query_exe_context_owned.get()};
173  CHECK(query_exe_context);
174  int32_t err{0};
175  uint32_t start_rowid{0};
176  if (rowid_lookup_key >= 0) {
177  if (!frag_list.empty()) {
178  const auto& all_frag_row_offsets = getFragOffsets();
179  start_rowid = rowid_lookup_key -
180  all_frag_row_offsets[frag_list.begin()->fragment_ids.front()];
181  }
182  }
183 
184  ResultSetPtr device_results;
185  if (ra_exe_unit_.groupby_exprs.empty()) {
186  err = executor_->executePlanWithoutGroupBy(ra_exe_unit_,
187  compilation_result,
188  query_comp_desc.hoistLiterals(),
189  device_results,
191  chosen_device_type,
192  fetch_result.col_buffers,
193  query_exe_context,
194  fetch_result.num_rows,
195  fetch_result.frag_offsets,
196  &cat_.getDataMgr(),
197  chosen_device_id,
198  start_rowid,
199  ra_exe_unit_.input_descs.size(),
200  do_render ? render_info_ : nullptr);
201  } else {
202  err = executor_->executePlanWithGroupBy(ra_exe_unit_,
203  compilation_result,
204  query_comp_desc.hoistLiterals(),
205  device_results,
206  chosen_device_type,
207  fetch_result.col_buffers,
208  outer_tab_frag_ids,
209  query_exe_context,
210  fetch_result.num_rows,
211  fetch_result.frag_offsets,
212  &cat_.getDataMgr(),
213  chosen_device_id,
215  start_rowid,
216  ra_exe_unit_.input_descs.size(),
217  do_render ? render_info_ : nullptr);
218  }
219  if (device_results) {
220  std::list<std::shared_ptr<Chunk_NS::Chunk>> chunks_to_hold;
221  for (const auto chunk : chunks) {
222  if (need_to_hold_chunk(chunk.get(), ra_exe_unit_)) {
223  chunks_to_hold.push_back(chunk);
224  }
225  }
226  device_results->holdChunks(chunks_to_hold);
227  device_results->holdChunkIterators(chunk_iterators_ptr);
228  }
229  if (err) {
230  throw QueryExecutionError(err);
231  }
232  {
233  std::lock_guard<std::mutex> lock(reduce_mutex_);
234  if (!needs_skip_result(device_results)) {
235  all_fragment_results_.emplace_back(std::move(device_results), outer_tab_frag_ids);
236  }
237  }
238 }
std::vector< Analyzer::Expr * > target_exprs
#define CHECK_EQ(x, y)
Definition: Logger.h:198
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:177
static const int max_gpu_count
Definition: Execute.h:991
#define LOG(tag)
Definition: Logger.h:185
bool needs_skip_result(const ResultSetPtr &res)
static std::mutex reduce_mutex_
Definition: Execute.h:549
#define CHECK_GE(x, y)
Definition: Logger.h:203
std::shared_ptr< ResultSet > ResultSetPtr
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
const std::vector< InputDescriptor > input_descs
#define CHECK_GT(x, y)
Definition: Logger.h:202
std::string to_string(char const *&&v)
CHECK(cgen_state)
const Catalog_Namespace::Catalog & cat_
Definition: Execute.h:542
const bool with_dynamic_watchdog
const std::vector< uint64_t > & getFragOffsets() const
const std::vector< InputTableInfo > & query_infos_
Definition: Execute.h:541
const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
Definition: Execute.h:545
uint64_t dynamic_watchdog_init(unsigned ms_budget)
static const int32_t ERR_OUT_OF_GPU_MEM
Definition: Execute.h:1034
QueryDescriptionType getQueryDescriptionType() const
#define CHECK_LT(x, y)
Definition: Logger.h:200
bool query_has_inner_join(const RelAlgExecutionUnit &ra_exe_unit)
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:547
std::atomic_flag dynamic_watchdog_set_
Definition: Execute.h:548
RenderInfo * render_info_
Definition: Execute.h:546
const unsigned dynamic_watchdog_time_limit
static const int32_t ERR_OUT_OF_CPU_MEM
Definition: Execute.h:1038
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:540

+ Here is the call graph for this function:

Friends And Related Function Documentation

friend class QueryCompilationDescriptor
friend

Definition at line 601 of file Execute.h.

Member Data Documentation

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

Definition at line 543 of file Execute.h.

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

Definition at line 544 of file Execute.h.

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

Definition at line 547 of file Execute.h.

Referenced by ExecutionDispatch(), and runImpl().

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

Definition at line 542 of file Execute.h.

Referenced by runImpl().

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

Definition at line 548 of file Execute.h.

Referenced by runImpl().

Executor* Executor::ExecutionDispatch::executor_
private

Definition at line 539 of file Execute.h.

Referenced by runImpl().

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

Definition at line 541 of file Execute.h.

Referenced by ExecutionDispatch(), and runImpl().

const RelAlgExecutionUnit& Executor::ExecutionDispatch::ra_exe_unit_
private

Definition at line 540 of file Execute.h.

Referenced by runImpl().

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

Definition at line 549 of file Execute.h.

Referenced by runImpl().

RenderInfo* Executor::ExecutionDispatch::render_info_
private

Definition at line 546 of file Execute.h.

Referenced by runImpl().

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

Definition at line 545 of file Execute.h.

Referenced by runImpl().


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