anonymous_namespace{ExecutionKernel.cpp} Namespace Reference

Functions
bool	needs_skip_result (const ResultSetPtr &res)
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, const std::vector< ColumnLazyFetchInfo > &lazy_fetch_info, const ExecutorDeviceType device_type)
bool	need_to_hold_chunk (const std::list< std::shared_ptr< Chunk_NS::Chunk >> &chunks, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< ColumnLazyFetchInfo > &lazy_fetch_info, const ExecutorDeviceType device_type)
size_t	get_available_cpu_threads_per_task (Executor *executor, SharedKernelContext &shared_context)

Function Documentation

size_t anonymous_namespace{ExecutionKernel.cpp}::get_available_cpu_threads_per_task	(	Executor *	executor,
		SharedKernelContext &	shared_context
	)

Definition at line 161 of file ExecutionKernel.cpp.

References CHECK_GE, cpu_threads(), and SharedKernelContext::getNumAllocatedThreads().

Referenced by ExecutionKernel::runImpl().

                                                                               {
  // total # allocated slots (i.e., threads) for compiled kernels of the input query
  auto const num_kernels = shared_context.getNumAllocatedThreads();
  CHECK_GE(num_kernels, 1u);
  size_t available_slots_per_task;
  if (executor->executor_resource_mgr_) {
    auto const resources_status = executor->executor_resource_mgr_->get_resource_info();
    // # available slots (i.e., threads) in the resource pool; idle threads
    auto const idle_cpu_slots =
        resources_status.total_cpu_slots - resources_status.allocated_cpu_slots;
    // we want to evenly use idle slots for each kernel task to avoid oversubscription
    available_slots_per_task = 1u + (idle_cpu_slots + num_kernels - 1u) / num_kernels;
  } else {
    available_slots_per_task = std::max(static_cast<size_t>(cpu_threads()) / num_kernels,
                                        static_cast<size_t>(1));
  }
  CHECK_GE(available_slots_per_task, 1u);
  return available_slots_per_task;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{ExecutionKernel.cpp}::need_to_hold_chunk	(	const Chunk_NS::Chunk *	chunk,
		const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< ColumnLazyFetchInfo > &	lazy_fetch_info,
		const ExecutorDeviceType	device_type
	)

Definition at line 45 of file ExecutionKernel.cpp.

References CHECK, CHECK_EQ, shared::ColumnKey::column_id, ColumnDescriptor::columnId, ColumnDescriptor::columnType, CPU, ColumnDescriptor::db_id, Chunk_NS::Chunk::getColumnDesc(), Analyzer::ColumnVar::getColumnKey(), kENCODING_NONE, ColumnDescriptor::tableId, and RelAlgExecutionUnit::target_exprs.

Referenced by need_to_hold_chunk(), and ExecutionKernel::runImpl().

                                                              {
  CHECK(chunk->getColumnDesc());
  const auto& chunk_ti = chunk->getColumnDesc()->columnType;
  if (device_type == ExecutorDeviceType::CPU &&
      (chunk_ti.is_array() ||
       (chunk_ti.is_string() && chunk_ti.get_compression() == kENCODING_NONE))) {
    for (const auto target_expr : ra_exe_unit.target_exprs) {
      const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
      if (col_var) {
        const auto& column_key = col_var->getColumnKey();
        return column_key.column_id == chunk->getColumnDesc()->columnId &&
               column_key.table_id == chunk->getColumnDesc()->tableId &&
               column_key.db_id == chunk->getColumnDesc()->db_id;
      }
    }
  }
  if (lazy_fetch_info.empty()) {
    return false;
  }
  CHECK_EQ(lazy_fetch_info.size(), ra_exe_unit.target_exprs.size());
  for (size_t i = 0; i < ra_exe_unit.target_exprs.size(); i++) {
    const auto target_expr = ra_exe_unit.target_exprs[i];
    const auto& col_lazy_fetch = lazy_fetch_info[i];
    const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
    if (col_var) {
      const auto& column_key = col_var->getColumnKey();
      if (column_key.column_id == chunk->getColumnDesc()->columnId &&
          column_key.table_id == chunk->getColumnDesc()->tableId &&
          column_key.db_id == chunk->getColumnDesc()->db_id) {
        if (col_lazy_fetch.is_lazily_fetched) {
          // hold lazy fetched inputs for later iteration
          return true;
        }
      }
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{ExecutionKernel.cpp}::need_to_hold_chunk	(	const std::list< std::shared_ptr< Chunk_NS::Chunk >> &	chunks,
		const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< ColumnLazyFetchInfo > &	lazy_fetch_info,
		const ExecutorDeviceType	device_type
	)

Definition at line 87 of file ExecutionKernel.cpp.

References need_to_hold_chunk().

                                                              {
  for (const auto& chunk : chunks) {
    if (need_to_hold_chunk(chunk.get(), ra_exe_unit, lazy_fetch_info, device_type)) {
      return true;
    }
  }

  return false;
}

Here is the call graph for this function:

bool anonymous_namespace{ExecutionKernel.cpp}::needs_skip_result

(

const ResultSetPtr &

res

)

Definition at line 32 of file ExecutionKernel.cpp.

Referenced by SharedKernelContext::addDeviceResults().

                                                {
  return !res || res->definitelyHasNoRows();
}

Here is the caller graph for this function:

bool anonymous_namespace{ExecutionKernel.cpp}::query_has_inner_join ( const RelAlgExecutionUnit &  ra_exe_unit )

inline

Definition at line 36 of file ExecutionKernel.cpp.

References INNER, and RelAlgExecutionUnit::join_quals.

Referenced by ExecutionKernel::runImpl().

                                                                         {
  return (std::count_if(ra_exe_unit.join_quals.begin(),
                        ra_exe_unit.join_quals.end(),
                        [](const auto& join_condition) {
                          return join_condition.type == JoinType::INNER;
                        }) > 0);
}

Here is the caller graph for this function: