#include <Execute.h>

Collaboration diagram for Executor:

Classes
struct	CompilationResult

class	ExecutionDispatch

class	FetchCacheAnchor

struct	FetchResult

struct	GroupColLLVMValue

struct	JoinHashTableOrError

Public Types
typedef std::tuple < std::string, const Analyzer::Expr *, int64_t, const size_t >	AggInfo

Public Member Functions
	Executor (const int db_id, const size_t block_size_x, const size_t grid_size_x, const std::string &debug_dir, const std::string &debug_file,::QueryRenderer::QueryRenderManager *render_manager)

std::shared_ptr< ResultSet >	execute (const Planner::RootPlan root_plan, const Catalog_Namespace::SessionInfo &session, const bool hoist_literals, const ExecutorDeviceType device_type, const ExecutorOptLevel, const bool allow_multifrag, const bool allow_loop_joins, RenderInfo render_query_data=nullptr)

std::shared_ptr< ResultSet >	renderPointsNonInSitu (const std::string &queryStr, const ExecutionResult &results, const Catalog_Namespace::SessionInfo &session, const int render_widget_id, const ::QueryRenderer::JSONLocation data_loc, RenderInfo render_query_data)

std::shared_ptr< ResultSet >	renderPointsInSitu (RenderInfo *render_query_data)

std::shared_ptr< ResultSet >	renderPolygonsNonInSitu (const std::string &queryStr, const ExecutionResult &results, const Catalog_Namespace::SessionInfo &session, const int render_widget_id, const ::QueryRenderer::JSONLocation data_loc, RenderInfo render_query_data, const std::string &poly_table_name)

std::shared_ptr< ResultSet >	renderLinesNonInSitu (const std::string &queryStr, const ExecutionResult &results, const Catalog_Namespace::SessionInfo &session, const int render_widget_id, const ::QueryRenderer::JSONLocation data_loc, RenderInfo render_query_data)

std::vector< int32_t >	getStringIds (const std::string &col_name, const std::vector< std::string > &col_vals, const ::QueryRenderer::QueryDataLayout query_data_layout, const ResultSet results, const std::shared_ptr< RowSetMemoryOwner > &row_set_mem_owner, const bool warn=false) const

std::vector< std::string >	getStringsFromIds (const std::string &col_name, const std::vector< int32_t > &ids, const ::QueryRenderer::QueryDataLayout query_data_layout, const ResultSet results, const std::shared_ptr< RowSetMemoryOwner > &row_set_mem_owner) const

StringDictionaryProxy *	getStringDictionaryProxy (const int dictId, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const bool with_generation) const

bool	isCPUOnly () const

bool	isArchMaxwell (const ExecutorDeviceType dt) const

bool	containsLeftDeepOuterJoin () const

const ColumnDescriptor *	getColumnDescriptor (const Analyzer::ColumnVar *) const

const ColumnDescriptor *	getPhysicalColumnDescriptor (const Analyzer::ColumnVar *, int) const

const Catalog_Namespace::Catalog *	getCatalog () const

void	setCatalog (const Catalog_Namespace::Catalog *catalog)

const std::shared_ptr < RowSetMemoryOwner >	getRowSetMemoryOwner () const

const TemporaryTables *	getTemporaryTables () const

Fragmenter_Namespace::TableInfo	getTableInfo (const int table_id) const

const TableGeneration &	getTableGeneration (const int table_id) const

ExpressionRange	getColRange (const PhysicalInput &) const

size_t	getNumBytesForFetchedRow () const

std::vector< ColumnLazyFetchInfo >	getColLazyFetchInfo (const std::vector< Analyzer::Expr * > &target_exprs) const

void	registerActiveModule (void *module, const int device_id) const

void	unregisterActiveModule (void *module, const int device_id) const

void	interrupt ()

void	resetInterrupt ()

int8_t	warpSize () const

unsigned	gridSize () const

unsigned	blockSize () const

void	setupCaching (const std::unordered_set< PhysicalInput > &phys_inputs, const std::unordered_set< int > &phys_table_ids)

Static Public Member Functions
static std::shared_ptr< Executor >	getExecutor (const int db_id, const std::string &debug_dir="", const std::string &debug_file="", const MapDParameters mapd_parameters=MapDParameters(),::QueryRenderer::QueryRenderManager *render_manager=nullptr)

static void	nukeCacheOfExecutors ()

static void	clearMemory (const Data_Namespace::MemoryLevel memory_level)

static std::pair< int64_t, int32_t >	reduceResults (const SQLAgg agg, const SQLTypeInfo &ti, const int64_t agg_init_val, const int8_t out_byte_width, const int64_t *out_vec, const size_t out_vec_sz, const bool is_group_by, const bool float_argument_input)

static void	addCodeToCache (const CodeCacheKey &, std::vector< std::tuple< void , ExecutionEngineWrapper >>, llvm::Module , CodeCache &)

Static Public Attributes
static const size_t	high_scan_limit

Private Types
using	PerFragmentCallBack = std::function< void(ResultSetPtr, const Fragmenter_Namespace::FragmentInfo &)>

Private Member Functions
void	clearMetaInfoCache ()

int	deviceCount (const ExecutorDeviceType) const

int	deviceCountForMemoryLevel (const Data_Namespace::MemoryLevel memory_level) const

llvm::Value *	codegenWindowFunction (const size_t target_index, const CompilationOptions &co)

llvm::Value *	codegenWindowFunctionAggregate (const CompilationOptions &co)

llvm::BasicBlock *	codegenWindowResetStateControlFlow ()

void	codegenWindowFunctionStateInit (llvm::Value *aggregate_state)

llvm::Value *	codegenWindowFunctionAggregateCalls (llvm::Value *aggregate_state, const CompilationOptions &co)

void	codegenWindowAvgEpilogue (llvm::Value crt_val, llvm::Value window_func_null_val, llvm::Value *multiplicity_lv)

llvm::Value *	codegenAggregateWindowState ()

llvm::Value *	aggregateWindowStatePtr ()

bool	isArchPascalOrLater (const ExecutorDeviceType dt) const

bool	needFetchAllFragments (const InputColDescriptor &col_desc, const RelAlgExecutionUnit &ra_exe_unit, const FragmentsList &selected_fragments) const

ResultSetPtr	executeWorkUnit (size_t &max_groups_buffer_entry_guess, const bool is_agg, const std::vector< InputTableInfo > &, const RelAlgExecutionUnit &, const CompilationOptions &, const ExecutionOptions &options, const Catalog_Namespace::Catalog &, std::shared_ptr< RowSetMemoryOwner >, RenderInfo *render_info, const bool has_cardinality_estimation, ColumnCacheMap &column_cache)

void	executeUpdate (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &table_infos, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const UpdateLogForFragment::Callback &cb, const bool is_agg=false)

void	executeWorkUnitPerFragment (const RelAlgExecutionUnit &ra_exe_unit, const InputTableInfo &table_info, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat, PerFragmentCallBack &cb)
	Compiles and dispatches a work unit per fragment processing results with the per fragment callback. Currently used for computing metrics over fragments (metadata). More...

ResultSetPtr	executeExplain (const QueryCompilationDescriptor &)

ResultSetPtr	executeTableFunction (const TableFunctionExecutionUnit exe_unit, const std::vector< InputTableInfo > &table_infos, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat)
	Compiles and dispatches a table function; that is, a function that takes as input one or more columns and returns a ResultSet, which can be parsed by subsequent execution steps. More...

ExecutorDeviceType	getDeviceTypeForTargets (const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType requested_device_type)

ResultSetPtr	collectAllDeviceResults (ExecutionDispatch &execution_dispatch, const std::vector< Analyzer::Expr * > &target_exprs, const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner)

ResultSetPtr	collectAllDeviceShardedTopResults (ExecutionDispatch &execution_dispatch) const

std::unordered_map< int, const Analyzer::BinOper * >	getInnerTabIdToJoinCond () const

void	dispatchFragments (const std::function< void(const ExecutorDeviceType chosen_device_type, int chosen_device_id, 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)> dispatch, const ExecutionDispatch &execution_dispatch, const std::vector< InputTableInfo > &table_infos, const ExecutionOptions &eo, const bool is_agg, const bool allow_single_frag_table_opt, const size_t context_count, const QueryCompilationDescriptor &query_comp_desc, const QueryMemoryDescriptor &query_mem_desc, QueryFragmentDescriptor &fragment_descriptor, std::unordered_set< int > &available_gpus, int &available_cpus)

std::vector< size_t >	getTableFragmentIndices (const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType device_type, const size_t table_idx, const size_t outer_frag_idx, std::map< int, const TableFragments * > &selected_tables_fragments, const std::unordered_map< int, const Analyzer::BinOper * > &inner_table_id_to_join_condition)

bool	skipFragmentPair (const Fragmenter_Namespace::FragmentInfo &outer_fragment_info, const Fragmenter_Namespace::FragmentInfo &inner_fragment_info, const int inner_table_id, const std::unordered_map< int, const Analyzer::BinOper * > &inner_table_id_to_join_condition, const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType device_type)

FetchResult	fetchChunks (const ColumnFetcher &, const RelAlgExecutionUnit &ra_exe_unit, const int device_id, const Data_Namespace::MemoryLevel, const std::map< int, const TableFragments * > &, const FragmentsList &selected_fragments, const Catalog_Namespace::Catalog &, std::list< ChunkIter > &, std::list< std::shared_ptr< Chunk_NS::Chunk >> &)

std::pair< std::vector < std::vector< int64_t > >, std::vector< std::vector < uint64_t > > >	getRowCountAndOffsetForAllFrags (const RelAlgExecutionUnit &ra_exe_unit, const CartesianProduct< std::vector< std::vector< size_t >>> &frag_ids_crossjoin, const std::vector< InputDescriptor > &input_descs, const std::map< int, const TableFragments * > &all_tables_fragments)

void	buildSelectedFragsMapping (std::vector< std::vector< size_t >> &selected_fragments_crossjoin, std::vector< size_t > &local_col_to_frag_pos, const std::list< std::shared_ptr< const InputColDescriptor >> &col_global_ids, const FragmentsList &selected_fragments, const RelAlgExecutionUnit &ra_exe_unit)

std::vector< size_t >	getFragmentCount (const FragmentsList &selected_fragments, const size_t scan_idx, const RelAlgExecutionUnit &ra_exe_unit)

int32_t	executePlanWithGroupBy (const RelAlgExecutionUnit &ra_exe_unit, const CompilationResult &, const bool hoist_literals, ResultSetPtr &results, const ExecutorDeviceType device_type, std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< size_t > outer_tab_frag_ids, QueryExecutionContext , const std::vector< std::vector< int64_t >> &num_rows, const std::vector< std::vector< uint64_t >> &frag_offsets, Data_Namespace::DataMgr , const int device_id, const int64_t limit, const uint32_t start_rowid, const uint32_t num_tables, RenderInfo *render_info)

int32_t	executePlanWithoutGroupBy (const RelAlgExecutionUnit &ra_exe_unit, const CompilationResult &, const bool hoist_literals, ResultSetPtr &results, const std::vector< Analyzer::Expr * > &target_exprs, const ExecutorDeviceType device_type, std::vector< std::vector< const int8_t * >> &col_buffers, QueryExecutionContext query_exe_context, const std::vector< std::vector< int64_t >> &num_rows, const std::vector< std::vector< uint64_t >> &frag_offsets, Data_Namespace::DataMgr data_mgr, const int device_id, const uint32_t start_rowid, const uint32_t num_tables, RenderInfo *render_info)

ResultSetPtr	resultsUnion (ExecutionDispatch &execution_dispatch)

std::vector< int64_t >	getJoinHashTablePtrs (const ExecutorDeviceType device_type, const int device_id)

ResultSetPtr	reduceMultiDeviceResults (const RelAlgExecutionUnit &, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const

ResultSetPtr	reduceMultiDeviceResultSets (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const

ResultSetPtr	reduceSpeculativeTopN (const RelAlgExecutionUnit &, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const

void	executeSimpleInsert (const Planner::RootPlan *root_plan)

ResultSetPtr	executeWorkUnitImpl (size_t &max_groups_buffer_entry_guess, const bool is_agg, const bool allow_single_frag_table_opt, const std::vector< InputTableInfo > &, const RelAlgExecutionUnit &, const CompilationOptions &, const ExecutionOptions &options, const Catalog_Namespace::Catalog &, std::shared_ptr< RowSetMemoryOwner >, RenderInfo *render_info, const bool has_cardinality_estimation, ColumnCacheMap &column_cache)

std::vector< llvm::Value * >	inlineHoistedLiterals ()

std::tuple < Executor::CompilationResult, std::unique_ptr < QueryMemoryDescriptor > >	compileWorkUnit (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo, const CudaMgr_Namespace::CudaMgr cuda_mgr, const bool allow_lazy_fetch, std::shared_ptr< RowSetMemoryOwner >, const size_t max_groups_buffer_entry_count, const int8_t crt_min_byte_width, const bool has_cardinality_estimation, ColumnCacheMap &column_cache, RenderInfo render_info=nullptr)

llvm::BasicBlock *	codegenSkipDeletedOuterTableRow (const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co)

std::vector< JoinLoop >	buildJoinLoops (RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo, const std::vector< InputTableInfo > &query_infos, ColumnCacheMap &column_cache)

std::function< llvm::Value (const std::vector < llvm::Value > &, llvm::Value *)>	buildIsDeletedCb (const RelAlgExecutionUnit &ra_exe_unit, const size_t level_idx, const CompilationOptions &co)

std::shared_ptr < JoinHashTableInterface >	buildCurrentLevelHashTable (const JoinCondition &current_level_join_conditions, RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const std::vector< InputTableInfo > &query_infos, ColumnCacheMap &column_cache, std::vector< std::string > &fail_reasons)

llvm::Value *	addJoinLoopIterator (const std::vector< llvm::Value * > &prev_iters, const size_t level_idx)

void	codegenJoinLoops (const std::vector< JoinLoop > &join_loops, const RelAlgExecutionUnit &ra_exe_unit, GroupByAndAggregate &group_by_and_aggregate, llvm::Function query_func, llvm::BasicBlock entry_bb, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const ExecutionOptions &eo)

bool	compileBody (const RelAlgExecutionUnit &ra_exe_unit, GroupByAndAggregate &group_by_and_aggregate, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co)

void	createErrorCheckControlFlow (llvm::Function *query_func, bool run_with_dynamic_watchdog, ExecutorDeviceType device_type)

void	preloadFragOffsets (const std::vector< InputDescriptor > &input_descs, const std::vector< InputTableInfo > &query_infos)

JoinHashTableOrError	buildHashTableForQualifier (const std::shared_ptr< Analyzer::BinOper > &qual_bin_oper, const std::vector< InputTableInfo > &query_infos, const MemoryLevel memory_level, const JoinHashTableInterface::HashType preferred_hash_type, ColumnCacheMap &column_cache)

void	nukeOldState (const bool allow_lazy_fetch, const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit *ra_exe_unit)

std::vector< std::pair< void , void > >	optimizeAndCodegenCPU (llvm::Function , llvm::Function , const std::unordered_set< llvm::Function * > &, const CompilationOptions &)

std::vector< std::pair< void , void > >	optimizeAndCodegenGPU (llvm::Function , llvm::Function , std::unordered_set< llvm::Function * > &, const bool no_inline, const CudaMgr_Namespace::CudaMgr *cuda_mgr, const CompilationOptions &)

std::string	generatePTX (const std::string &) const

void	initializeNVPTXBackend () const

int64_t	deviceCycles (int milliseconds) const

GroupColLLVMValue	groupByColumnCodegen (Analyzer::Expr group_by_col, const size_t col_width, const CompilationOptions &, const bool translate_null_val, const int64_t translated_null_val, GroupByAndAggregate::DiamondCodegen &, std::stack< llvm::BasicBlock > &, const bool thread_mem_shared)

llvm::Value *	castToFP (llvm::Value *val)

llvm::Value *	castToIntPtrTyIn (llvm::Value *val, const size_t bit_width)

RelAlgExecutionUnit	addDeletedColumn (const RelAlgExecutionUnit &ra_exe_unit)

std::pair< bool, int64_t >	skipFragment (const InputDescriptor &table_desc, const Fragmenter_Namespace::FragmentInfo &frag_info, const std::list< std::shared_ptr< Analyzer::Expr >> &simple_quals, const std::vector< uint64_t > &frag_offsets, const size_t frag_idx)

std::pair< bool, int64_t >	skipFragmentInnerJoins (const InputDescriptor &table_desc, const RelAlgExecutionUnit &ra_exe_unit, const Fragmenter_Namespace::FragmentInfo &fragment, const std::vector< uint64_t > &frag_offsets, const size_t frag_idx)

AggregatedColRange	computeColRangesCache (const std::unordered_set< PhysicalInput > &phys_inputs)

StringDictionaryGenerations	computeStringDictionaryGenerations (const std::unordered_set< PhysicalInput > &phys_inputs)

TableGenerations	computeTableGenerations (std::unordered_set< int > phys_table_ids)

std::vector< std::pair< void , void > >	getCodeFromCache (const CodeCacheKey &, const CodeCache &)

void	addCodeToCache (const CodeCacheKey &, const std::vector< std::tuple< void , GpuCompilationContext >> &, llvm::Module *, CodeCache &)

std::vector< int8_t >	serializeLiterals (const std::unordered_map< int, CgenState::LiteralValues > &literals, const int device_id)

llvm::Value *	spillDoubleElement (llvm::Value elem_val, llvm::Type elem_ty)

Static Private Member Functions
static size_t	align (const size_t off_in, const size_t alignment)

Private Attributes
std::unique_ptr< CgenState >	cgen_state_

std::unique_ptr< PlanState >	plan_state_

std::shared_ptr < RowSetMemoryOwner >	row_set_mem_owner_

std::mutex	gpu_exec_mutex_ [max_gpu_count]

std::mutex	gpu_active_modules_mutex_

uint32_t	gpu_active_modules_device_mask_

void *	gpu_active_modules_ [max_gpu_count]

bool	interrupted_

std::shared_ptr < StringDictionaryProxy >	lit_str_dict_proxy_

std::mutex	str_dict_mutex_

std::unique_ptr < llvm::TargetMachine >	nvptx_target_machine_

CodeCache	cpu_code_cache_

CodeCache	gpu_code_cache_

::QueryRenderer::QueryRenderManager *	render_manager_

const unsigned	block_size_x_

const unsigned	grid_size_x_

const std::string	debug_dir_

const std::string	debug_file_

const int	db_id_

const Catalog_Namespace::Catalog *	catalog_

const TemporaryTables *	temporary_tables_

InputTableInfoCache	input_table_info_cache_

AggregatedColRange	agg_col_range_cache_

StringDictionaryGenerations	string_dictionary_generations_

TableGenerations	table_generations_

Static Private Attributes
static const int	max_gpu_count {16}

static const size_t	baseline_threshold

static const size_t	code_cache_size {10000}

static std::map< std::pair < int,::QueryRenderer::QueryRenderManager * > , std::shared_ptr< Executor > >	executors_

static std::mutex	execute_mutex_

static mapd_shared_mutex	executors_cache_mutex_

static const int32_t	ERR_DIV_BY_ZERO {1}

static const int32_t	ERR_OUT_OF_GPU_MEM {2}

static const int32_t	ERR_OUT_OF_SLOTS {3}

static const int32_t	ERR_UNSUPPORTED_SELF_JOIN {4}

static const int32_t	ERR_OUT_OF_RENDER_MEM {5}

static const int32_t	ERR_OUT_OF_CPU_MEM {6}

static const int32_t	ERR_OVERFLOW_OR_UNDERFLOW {7}

static const int32_t	ERR_SPECULATIVE_TOP_OOM {8}

static const int32_t	ERR_OUT_OF_TIME {9}

static const int32_t	ERR_INTERRUPTED {10}

static const int32_t	ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED {11}

static const int32_t	ERR_TOO_MANY_LITERALS {12}

static const int32_t	ERR_STRING_CONST_IN_RESULTSET {13}

static const int32_t	ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY {14}

Friends
class	BaselineJoinHashTable

class	CodeGenerator

class	ColumnFetcher

class	OverlapsJoinHashTable

class	GroupByAndAggregate

class	QueryCompilationDescriptor

class	QueryMemoryDescriptor

class	QueryMemoryInitializer

class	QueryFragmentDescriptor

class	QueryExecutionContext

class	ResultSet

class	InValuesBitmap

class	JoinHashTable

class	LeafAggregator

class	QueryRewriter

class	PendingExecutionClosure

class	RelAlgExecutor

class	TableOptimizer

class	TableFunctionCompilationContext

class	TableFunctionExecutionContext

struct	TargetExprCodegenBuilder

struct	TargetExprCodegen

template<typename META_TYPE_CLASS >
class	AggregateReductionEgress

Detailed Description

Definition at line 330 of file Execute.h.

Member Typedef Documentation

typedef std::tuple<std::string, const Analyzer::Expr*, int64_t, const size_t> Executor::AggInfo

Definition at line 360 of file Execute.h.

using Executor::PerFragmentCallBack = std::function<void(ResultSetPtr, const Fragmenter_Namespace::FragmentInfo&)>

private

Definition at line 626 of file Execute.h.

Constructor & Destructor Documentation

Executor::Executor	(	const int	db_id,
		const size_t	block_size_x,
		const size_t	grid_size_x,
		const std::string &	debug_dir,
		const std::string &	debug_file,
		::QueryRenderer::QueryRenderManager *	render_manager
	)

Definition at line 106 of file Execute.cpp.

112 : cgen_state_(new CgenState({}, false))

Executor::cgen_state_

std::unique_ptr< CgenState > cgen_state_

Definition: Execute.h:973

CgenState

Definition: CgenState.h:30

Member Function Documentation

static void Executor::addCodeToCache	(	const CodeCacheKey &	,
		std::vector< std::tuple< void *, ExecutionEngineWrapper >>	,
		llvm::Module *	,
		CodeCache &
	)

static

Referenced by StubGenerator::generateStub().

Here is the caller graph for this function:

void Executor::addCodeToCache	(	const CodeCacheKey &	,
		const std::vector< std::tuple< void , GpuCompilationContext >> &	,
		llvm::Module *	,
		CodeCache &
	)

private

RelAlgExecutionUnit Executor::addDeletedColumn ( const RelAlgExecutionUnit & ra_exe_unit )

private

Definition at line 3034 of file Execute.cpp.

References catalog_(), CHECK(), and TABLE.

                                                                                      {
   auto ra_exe_unit_with_deleted = ra_exe_unit;
   for (const auto& input_table : ra_exe_unit_with_deleted.input_descs) {
     if (input_table.getSourceType() != InputSourceType::TABLE) {
       continue;
     }
     const auto td = catalog_->getMetadataForTable(input_table.getTableId());
     CHECK(td);
     const auto deleted_cd = catalog_->getDeletedColumnIfRowsDeleted(td);
     if (!deleted_cd) {
       continue;
     }
     CHECK(deleted_cd->columnType.is_boolean());
     // check deleted column is not already present
     bool found = false;
     for (const auto& input_col : ra_exe_unit_with_deleted.input_col_descs) {
       if (input_col.get()->getColId() == deleted_cd->columnId &&
           input_col.get()->getScanDesc().getTableId() == deleted_cd->tableId &&
           input_col.get()->getScanDesc().getNestLevel() == input_table.getNestLevel()) {
         found = true;
       }
     }
     if (!found) {
       // add deleted column
       ra_exe_unit_with_deleted.input_col_descs.emplace_back(new InputColDescriptor(
           deleted_cd->columnId, deleted_cd->tableId, input_table.getNestLevel()));
     }
   }
   return ra_exe_unit_with_deleted;
 }

Here is the call graph for this function:

llvm::Value * Executor::addJoinLoopIterator	(	const std::vector< llvm::Value * > &	prev_iters,
		const size_t	level_idx
	)

private

Definition at line 442 of file IRCodegen.cpp.

References CHECK().

                                                                    {
   // Iterators are added for loop-outer joins when the head of the loop is generated,
   // then once again when the body if generated. Allow this instead of special handling
   // of call sites.
   const auto it = cgen_state_->scan_idx_to_hash_pos_.find(level_idx);
   if (it != cgen_state_->scan_idx_to_hash_pos_.end()) {
     return it->second;
   }
   CHECK(!prev_iters.empty());
   llvm::Value* matching_row_index = prev_iters.back();
   const auto it_ok =
       cgen_state_->scan_idx_to_hash_pos_.emplace(level_idx, matching_row_index);
   CHECK(it_ok.second);
   return matching_row_index;
 }

Here is the call graph for this function:

llvm::Value * Executor::aggregateWindowStatePtr ( )

private

Definition at line 122 of file WindowFunctionIR.cpp.

References anonymous_namespace{WindowFunctionIR.cpp}::get_adjusted_window_type_info(), get_int_type(), WindowProjectNodeContext::getActiveWindowFunctionContext(), and kFLOAT.

                                              {
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto window_func = window_func_context->getWindowFunction();
   const auto arg_ti = get_adjusted_window_type_info(window_func);
   llvm::Type* aggregate_state_type =
       arg_ti.get_type() == kFLOAT
           ? llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0)
           : llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0);
   const auto aggregate_state_i64 = cgen_state_->llInt(
       reinterpret_cast<const int64_t>(window_func_context->aggregateState()));
   return cgen_state_->ir_builder_.CreateIntToPtr(aggregate_state_i64,
                                                  aggregate_state_type);
 }

Here is the call graph for this function:

static size_t Executor::align	(	const size_t	off_in,
		const size_t	alignment
	)

inlinestaticprivate

Definition at line 965 of file Execute.h.

                                                                    {
     size_t off = off_in;
     if (off % alignment != 0) {
       off += (alignment - off % alignment);
     }
     return off;
   }

unsigned Executor::blockSize ( ) const

Definition at line 2968 of file Execute.cpp.

References block_size_x_(), catalog_(), and CHECK().

                                    {
   CHECK(catalog_);
   const auto cuda_mgr = catalog_->getDataMgr().getCudaMgr();
   CHECK(cuda_mgr);
   const auto& dev_props = cuda_mgr->getAllDeviceProperties();
   return block_size_x_ ? block_size_x_ : dev_props.front().maxThreadsPerBlock;
 }

Here is the call graph for this function:

std::shared_ptr< JoinHashTableInterface > Executor::buildCurrentLevelHashTable	(	const JoinCondition &	current_level_join_conditions,
		RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationOptions &	co,
		const std::vector< InputTableInfo > &	query_infos,
		ColumnCacheMap &	column_cache,
		std::vector< std::string > &	fail_reasons
	)

private

Definition at line 396 of file IRCodegen.cpp.

References anonymous_namespace{IRCodegen.cpp}::add_qualifier_to_execution_unit(), Data_Namespace::CPU_LEVEL, CompilationOptions::device_type_, Executor::JoinHashTableOrError::fail_reason, GPU, Data_Namespace::GPU_LEVEL, Executor::JoinHashTableOrError::hash_table, INNER, IS_EQUIVALENCE, JoinHashTableInterface::OneToOne, JoinCondition::quals, and JoinCondition::type.

                                         {
   if (current_level_join_conditions.type != JoinType::INNER &&
       current_level_join_conditions.quals.size() > 1) {
     fail_reasons.emplace_back("No equijoin expression found for outer join");
     return nullptr;
   }
   std::shared_ptr<JoinHashTableInterface> current_level_hash_table;
   for (const auto& join_qual : current_level_join_conditions.quals) {
     auto qual_bin_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(join_qual);
     if (!qual_bin_oper || !IS_EQUIVALENCE(qual_bin_oper->get_optype())) {
       fail_reasons.emplace_back("No equijoin expression found");
       if (current_level_join_conditions.type == JoinType::INNER) {
         add_qualifier_to_execution_unit(ra_exe_unit, join_qual);
       }
       continue;
     }
     JoinHashTableOrError hash_table_or_error;
     if (!current_level_hash_table) {
       hash_table_or_error = buildHashTableForQualifier(
           qual_bin_oper,
           query_infos,
           co.device_type_ == ExecutorDeviceType::GPU ? MemoryLevel::GPU_LEVEL
                                                      : MemoryLevel::CPU_LEVEL,
           JoinHashTableInterface::HashType::OneToOne,
           column_cache);
       current_level_hash_table = hash_table_or_error.hash_table;
     }
     if (hash_table_or_error.hash_table) {
       plan_state_->join_info_.join_hash_tables_.push_back(hash_table_or_error.hash_table);
       plan_state_->join_info_.equi_join_tautologies_.push_back(qual_bin_oper);
     } else {
       fail_reasons.push_back(hash_table_or_error.fail_reason);
       if (current_level_join_conditions.type == JoinType::INNER) {
         add_qualifier_to_execution_unit(ra_exe_unit, qual_bin_oper);
       }
     }
   }
   return current_level_hash_table;
 }

Here is the call graph for this function:

Executor::JoinHashTableOrError Executor::buildHashTableForQualifier	(	const std::shared_ptr< Analyzer::BinOper > &	qual_bin_oper,
		const std::vector< InputTableInfo > &	query_infos,
		const MemoryLevel	memory_level,
		const JoinHashTableInterface::HashType	preferred_hash_type,
		ColumnCacheMap &	column_cache
	)

private

Definition at line 2894 of file Execute.cpp.

References CHECK(), CHECK_EQ, CHECK_GT, coalesce_singleton_equi_join(), g_enable_overlaps_hashjoin, OverlapsJoinHashTable::getInstance(), BaselineJoinHashTable::getInstance(), and JoinHashTable::getInstance().

                                   {
   std::shared_ptr<JoinHashTableInterface> join_hash_table;
   const int device_count = deviceCountForMemoryLevel(memory_level);
   CHECK_GT(device_count, 0);
   if (!g_enable_overlaps_hashjoin && qual_bin_oper->is_overlaps_oper()) {
     return {nullptr, "Overlaps hash join disabled, attempting to fall back to loop join"};
   }
   try {
     if (qual_bin_oper->is_overlaps_oper()) {
       join_hash_table = OverlapsJoinHashTable::getInstance(
           qual_bin_oper, query_infos, memory_level, device_count, column_cache, this);
     } else if (dynamic_cast<const Analyzer::ExpressionTuple*>(
                    qual_bin_oper->get_left_operand())) {
       join_hash_table = BaselineJoinHashTable::getInstance(qual_bin_oper,
                                                            query_infos,
                                                            memory_level,
                                                            preferred_hash_type,
                                                            device_count,
                                                            column_cache,
                                                            this);
     } else {
       try {
         join_hash_table = JoinHashTable::getInstance(qual_bin_oper,
                                                      query_infos,
                                                      memory_level,
                                                      preferred_hash_type,
                                                      device_count,
                                                      column_cache,
                                                      this);
       } catch (TooManyHashEntries&) {
         const auto join_quals = coalesce_singleton_equi_join(qual_bin_oper);
         CHECK_EQ(join_quals.size(), size_t(1));
         const auto join_qual =
             std::dynamic_pointer_cast<Analyzer::BinOper>(join_quals.front());
         join_hash_table = BaselineJoinHashTable::getInstance(join_qual,
                                                              query_infos,
                                                              memory_level,
                                                              preferred_hash_type,
                                                              device_count,
                                                              column_cache,
                                                              this);
       }
     }
     CHECK(join_hash_table);
     return {join_hash_table, ""};
   } catch (const HashJoinFail& e) {
     return {nullptr, e.what()};
   }
   CHECK(false);
   return {nullptr, ""};
 }

Here is the call graph for this function:

std::function< llvm::Value (const std::vector< llvm::Value > &, llvm::Value *)> Executor::buildIsDeletedCb	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const size_t	level_idx,
		const CompilationOptions &	co
	)

private

Definition at line 340 of file IRCodegen.cpp.

References catalog_(), CHECK(), CHECK_LT, CodeGenerator::codegen(), RelAlgExecutionUnit::input_descs, TABLE, and CodeGenerator::toBool().

                                                          {
   CHECK_LT(level_idx + 1, ra_exe_unit.input_descs.size());
   const auto input_desc = ra_exe_unit.input_descs[level_idx + 1];
   if (input_desc.getSourceType() != InputSourceType::TABLE) {
     return nullptr;
   }
   const auto td = catalog_->getMetadataForTable(input_desc.getTableId());
   CHECK(td);
   const auto deleted_cd = catalog_->getDeletedColumnIfRowsDeleted(td);
   if (!deleted_cd) {
     return nullptr;
   }
   CHECK(deleted_cd->columnType.is_boolean());
   const auto deleted_expr = makeExpr<Analyzer::ColumnVar>(deleted_cd->columnType,
                                                           input_desc.getTableId(),
                                                           deleted_cd->columnId,
                                                           input_desc.getNestLevel());
   return [this, deleted_expr, level_idx, &co](const std::vector<llvm::Value*>& prev_iters,
                                               llvm::Value* have_more_inner_rows) {
     const auto matching_row_index = addJoinLoopIterator(prev_iters, level_idx + 1);
     // Avoid fetching the deleted column from a position which is not valid.
     // An invalid position can be returned by a one to one hash lookup (negative)
     // or at the end of iteration over a set of matching values.
     llvm::Value* is_valid_it{nullptr};
     if (have_more_inner_rows) {
       is_valid_it = have_more_inner_rows;
     } else {
       is_valid_it = cgen_state_->ir_builder_.CreateICmp(
           llvm::ICmpInst::ICMP_SGE, matching_row_index, cgen_state_->llInt<int64_t>(0));
     }
     const auto it_valid_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "it_valid", cgen_state_->row_func_);
     const auto it_not_valid_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "it_not_valid", cgen_state_->row_func_);
     cgen_state_->ir_builder_.CreateCondBr(is_valid_it, it_valid_bb, it_not_valid_bb);
     const auto row_is_deleted_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "row_is_deleted", cgen_state_->row_func_);
     cgen_state_->ir_builder_.SetInsertPoint(it_valid_bb);
     CodeGenerator code_generator(this);
     const auto row_is_deleted = code_generator.toBool(
         code_generator.codegen(deleted_expr.get(), true, co).front());
     cgen_state_->ir_builder_.CreateBr(row_is_deleted_bb);
     cgen_state_->ir_builder_.SetInsertPoint(it_not_valid_bb);
     const auto row_is_deleted_default = cgen_state_->llBool(false);
     cgen_state_->ir_builder_.CreateBr(row_is_deleted_bb);
     cgen_state_->ir_builder_.SetInsertPoint(row_is_deleted_bb);
     auto row_is_deleted_or_default =
         cgen_state_->ir_builder_.CreatePHI(row_is_deleted->getType(), 2);
     row_is_deleted_or_default->addIncoming(row_is_deleted, it_valid_bb);
     row_is_deleted_or_default->addIncoming(row_is_deleted_default, it_not_valid_bb);
     return row_is_deleted_or_default;
   };
 }

Here is the call graph for this function:

std::vector< JoinLoop > Executor::buildJoinLoops	(	RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo,
		const std::vector< InputTableInfo > &	query_infos,
		ColumnCacheMap &	column_cache
	)

private

Definition at line 218 of file IRCodegen.cpp.

References CodeGenerator::cgen_state_, CHECK(), CHECK_LT, INJECT_TIMER, RelAlgExecutionUnit::join_quals, LEFT, JoinHashTableInterface::OneToOne, CgenState::outer_join_match_found_per_level_, Set, Singleton, JoinLoopDomain::slot_lookup_result, and JoinLoopDomain::values_buffer.

                                   {
   INJECT_TIMER(buildJoinLoops);
   std::vector<JoinLoop> join_loops;
   for (size_t level_idx = 0, current_hash_table_idx = 0;
        level_idx < ra_exe_unit.join_quals.size();
        ++level_idx) {
     const auto& current_level_join_conditions = ra_exe_unit.join_quals[level_idx];
     std::vector<std::string> fail_reasons;
     const auto current_level_hash_table =
         buildCurrentLevelHashTable(current_level_join_conditions,
                                    ra_exe_unit,
                                    co,
                                    query_infos,
                                    column_cache,
                                    fail_reasons);
     const auto found_outer_join_matches_cb =
         [this, level_idx](llvm::Value* found_outer_join_matches) {
           CHECK_LT(level_idx, cgen_state_->outer_join_match_found_per_level_.size());
           CHECK(!cgen_state_->outer_join_match_found_per_level_[level_idx]);
           cgen_state_->outer_join_match_found_per_level_[level_idx] =
               found_outer_join_matches;
         };
     const auto is_deleted_cb = buildIsDeletedCb(ra_exe_unit, level_idx, co);
     if (current_level_hash_table) {
       if (current_level_hash_table->getHashType() == JoinHashTable::HashType::OneToOne) {
         join_loops.emplace_back(
             JoinLoopKind::Singleton,
             current_level_join_conditions.type,
             [this, current_hash_table_idx, level_idx, current_level_hash_table, &co](
                 const std::vector<llvm::Value*>& prev_iters) {
               addJoinLoopIterator(prev_iters, level_idx);
               JoinLoopDomain domain{{0}};
               domain.slot_lookup_result =
                   current_level_hash_table->codegenSlot(co, current_hash_table_idx);
               return domain;
             },
             nullptr,
             current_level_join_conditions.type == JoinType::LEFT
                 ? std::function<void(llvm::Value*)>(found_outer_join_matches_cb)
                 : nullptr,
             is_deleted_cb);
       } else {
         join_loops.emplace_back(
             JoinLoopKind::Set,
             current_level_join_conditions.type,
             [this, current_hash_table_idx, level_idx, current_level_hash_table, &co](
                 const std::vector<llvm::Value*>& prev_iters) {
               addJoinLoopIterator(prev_iters, level_idx);
               JoinLoopDomain domain{{0}};
               const auto matching_set = current_level_hash_table->codegenMatchingSet(
                   co, current_hash_table_idx);
               domain.values_buffer = matching_set.elements;
               domain.element_count = matching_set.count;
               return domain;
             },
             nullptr,
             current_level_join_conditions.type == JoinType::LEFT
                 ? std::function<void(llvm::Value*)>(found_outer_join_matches_cb)
                 : nullptr,
             is_deleted_cb);
       }
       ++current_hash_table_idx;
     } else {
       const auto fail_reasons_str = current_level_join_conditions.quals.empty()
                                         ? "No equijoin expression found"
                                         : boost::algorithm::join(fail_reasons, " | ");
       check_if_loop_join_is_allowed(
           ra_exe_unit, eo, query_infos, level_idx, fail_reasons_str);
       // Callback provided to the `JoinLoop` framework to evaluate the (outer) join
       // condition.
       VLOG(1) << "Unable to build hash table, falling back to loop join: "
               << fail_reasons_str;
       const auto outer_join_condition_cb =
           [this, level_idx, &co, &current_level_join_conditions](
               const std::vector<llvm::Value*>& prev_iters) {
             // The values generated for the match path don't dominate all uses
             // since on the non-match path nulls are generated. Reset the cache
             // once the condition is generated to avoid incorrect reuse.
             FetchCacheAnchor anchor(cgen_state_.get());
             addJoinLoopIterator(prev_iters, level_idx + 1);
             llvm::Value* left_join_cond = cgen_state_->llBool(true);
             CodeGenerator code_generator(this);
             for (auto expr : current_level_join_conditions.quals) {
               left_join_cond = cgen_state_->ir_builder_.CreateAnd(
                   left_join_cond,
                   code_generator.toBool(
                       code_generator.codegen(expr.get(), true, co).front()));
             }
             return left_join_cond;
           };
       join_loops.emplace_back(
           JoinLoopKind::UpperBound,
           current_level_join_conditions.type,
           [this, level_idx](const std::vector<llvm::Value*>& prev_iters) {
             addJoinLoopIterator(prev_iters, level_idx);
             JoinLoopDomain domain{{0}};
             const auto rows_per_scan_ptr = cgen_state_->ir_builder_.CreateGEP(
                 get_arg_by_name(cgen_state_->row_func_, "num_rows_per_scan"),
                 cgen_state_->llInt(int32_t(level_idx + 1)));
             domain.upper_bound = cgen_state_->ir_builder_.CreateLoad(rows_per_scan_ptr,
                                                                      "num_rows_per_scan");
             return domain;
           },
           current_level_join_conditions.type == JoinType::LEFT
               ? std::function<llvm::Value*(const std::vector<llvm::Value*>&)>(
                     outer_join_condition_cb)
               : nullptr,
           current_level_join_conditions.type == JoinType::LEFT
               ? std::function<void(llvm::Value*)>(found_outer_join_matches_cb)
               : nullptr,
           is_deleted_cb);
     }
   }
   return join_loops;
 }

Here is the call graph for this function:

void Executor::buildSelectedFragsMapping	(	std::vector< std::vector< size_t >> &	selected_fragments_crossjoin,
		std::vector< size_t > &	local_col_to_frag_pos,
		const std::list< std::shared_ptr< const InputColDescriptor >> &	col_global_ids,
		const FragmentsList &	selected_fragments,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

private

Definition at line 2116 of file Execute.cpp.

References CHECK(), CHECK_EQ, CHECK_LT, and RelAlgExecutionUnit::input_descs.

                                             {
   local_col_to_frag_pos.resize(plan_state_->global_to_local_col_ids_.size());
   size_t frag_pos{0};
   const auto& input_descs = ra_exe_unit.input_descs;
   for (size_t scan_idx = 0; scan_idx < input_descs.size(); ++scan_idx) {
     const int table_id = input_descs[scan_idx].getTableId();
     CHECK_EQ(selected_fragments[scan_idx].table_id, table_id);
     selected_fragments_crossjoin.push_back(
         getFragmentCount(selected_fragments, scan_idx, ra_exe_unit));
     for (const auto& col_id : col_global_ids) {
       CHECK(col_id);
       const auto& input_desc = col_id->getScanDesc();
       if (input_desc.getTableId() != table_id ||
           input_desc.getNestLevel() != static_cast<int>(scan_idx)) {
         continue;
       }
       auto it = plan_state_->global_to_local_col_ids_.find(*col_id);
       CHECK(it != plan_state_->global_to_local_col_ids_.end());
       CHECK_LT(static_cast<size_t>(it->second),
                plan_state_->global_to_local_col_ids_.size());
       local_col_to_frag_pos[it->second] = frag_pos;
     }
     ++frag_pos;
   }
 }

Here is the call graph for this function:

llvm::Value * Executor::castToFP ( llvm::Value * val )

private

Definition at line 2984 of file Execute.cpp.

References CHECK().

                                             {
   if (!val->getType()->isIntegerTy()) {
     return val;
   }
 
   auto val_width = static_cast<llvm::IntegerType*>(val->getType())->getBitWidth();
   llvm::Type* dest_ty{nullptr};
   switch (val_width) {
     case 32:
       dest_ty = llvm::Type::getFloatTy(cgen_state_->context_);
       break;
     case 64:
       dest_ty = llvm::Type::getDoubleTy(cgen_state_->context_);
       break;
     default:
       CHECK(false);
   }
   return cgen_state_->ir_builder_.CreateSIToFP(val, dest_ty);
 }

Here is the call graph for this function:

llvm::Value * Executor::castToIntPtrTyIn	(	llvm::Value *	val,
		const size_t	bit_width
	)

private

Definition at line 3004 of file Execute.cpp.

References CHECK(), CHECK_LT, and get_int_type().

                                                                            {
   CHECK(val->getType()->isPointerTy());
 
   const auto val_ptr_type = static_cast<llvm::PointerType*>(val->getType());
   const auto val_type = val_ptr_type->getElementType();
   size_t val_width = 0;
   if (val_type->isIntegerTy()) {
     val_width = val_type->getIntegerBitWidth();
   } else {
     if (val_type->isFloatTy()) {
       val_width = 32;
     } else {
       CHECK(val_type->isDoubleTy());
       val_width = 64;
     }
   }
   CHECK_LT(size_t(0), val_width);
   if (bitWidth == val_width) {
     return val;
   }
   return cgen_state_->ir_builder_.CreateBitCast(
       val, llvm::PointerType::get(get_int_type(bitWidth, cgen_state_->context_), 0));
 }

Here is the call graph for this function:

void Executor::clearMemory ( const Data_Namespace::MemoryLevel memory_level )

static

Definition at line 160 of file Execute.cpp.

References Data_Namespace::DataMgr::clearMemory(), Data_Namespace::CPU_LEVEL, Catalog_Namespace::SysCatalog::getDataMgr(), Data_Namespace::GPU_LEVEL, Catalog_Namespace::SysCatalog::instance(), and CacheInvalidator< CACHE_HOLDING_TYPES >::invalidateCaches().

Referenced by MapDHandler::clear_cpu_memory(), MapDHandler::clear_gpu_memory(), QueryRunner::QueryRunner::clearCpuMemory(), and QueryRunner::QueryRunner::clearGpuMemory().

                                                                        {
   switch (memory_level) {
     case Data_Namespace::MemoryLevel::CPU_LEVEL:
     case Data_Namespace::MemoryLevel::GPU_LEVEL: {
       std::lock_guard<std::mutex> flush_lock(
           execute_mutex_);  // Don't flush memory while queries are running
 
       Catalog_Namespace::SysCatalog::instance().getDataMgr().clearMemory(memory_level);
       if (memory_level == Data_Namespace::MemoryLevel::CPU_LEVEL) {
         // The hash table cache uses CPU memory not managed by the buffer manager. In the
         // future, we should manage these allocations with the buffer manager directly.
         // For now, assume the user wants to purge the hash table cache when they clear
         // CPU memory (currently used in ExecuteTest to lower memory pressure)
         JoinHashTableCacheInvalidator::invalidateCaches();
       }
       break;
     }
     default: {
       throw std::runtime_error(
           "Clearing memory levels other than the CPU level or GPU level is not "
           "supported.");
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Executor::clearMetaInfoCache ( )

private

Definition at line 328 of file Execute.cpp.

References input_table_info_cache_().

                                   {
   input_table_info_cache_.clear();
   agg_col_range_cache_.clear();
   string_dictionary_generations_.clear();
   table_generations_.clear();
 }

Here is the call graph for this function:

llvm::Value * Executor::codegenAggregateWindowState ( )

private

Definition at line 318 of file WindowFunctionIR.cpp.

References AVG, COUNT, anonymous_namespace{WindowFunctionIR.cpp}::get_adjusted_window_type_info(), get_int_type(), WindowProjectNodeContext::getActiveWindowFunctionContext(), Analyzer::WindowFunction::getKind(), kDECIMAL, kDOUBLE, and kFLOAT.

                                                  {
   const auto pi32_type =
       llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0);
   const auto pi64_type =
       llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0);
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const Analyzer::WindowFunction* window_func = window_func_context->getWindowFunction();
   const auto window_func_ti = get_adjusted_window_type_info(window_func);
   const auto aggregate_state_type =
       window_func_ti.get_type() == kFLOAT ? pi32_type : pi64_type;
   auto aggregate_state = aggregateWindowStatePtr();
   if (window_func->getKind() == SqlWindowFunctionKind::AVG) {
     const auto aggregate_state_count_i64 = cgen_state_->llInt(
         reinterpret_cast<const int64_t>(window_func_context->aggregateStateCount()));
     auto aggregate_state_count = cgen_state_->ir_builder_.CreateIntToPtr(
         aggregate_state_count_i64, aggregate_state_type);
     const auto double_null_lv = cgen_state_->inlineFpNull(SQLTypeInfo(kDOUBLE));
     switch (window_func_ti.get_type()) {
       case kFLOAT: {
         return cgen_state_->emitCall(
             "load_avg_float", {aggregate_state, aggregate_state_count, double_null_lv});
       }
       case kDOUBLE: {
         return cgen_state_->emitCall(
             "load_avg_double", {aggregate_state, aggregate_state_count, double_null_lv});
       }
       case kDECIMAL: {
         return cgen_state_->emitCall(
             "load_avg_decimal",
             {aggregate_state,
              aggregate_state_count,
              double_null_lv,
              cgen_state_->llInt<int32_t>(window_func_ti.get_scale())});
       }
       default: {
         return cgen_state_->emitCall(
             "load_avg_int", {aggregate_state, aggregate_state_count, double_null_lv});
       }
     }
   }
   if (window_func->getKind() == SqlWindowFunctionKind::COUNT) {
     return cgen_state_->ir_builder_.CreateLoad(aggregate_state);
   }
   switch (window_func_ti.get_type()) {
     case kFLOAT: {
       return cgen_state_->emitCall("load_float", {aggregate_state});
     }
     case kDOUBLE: {
       return cgen_state_->emitCall("load_double", {aggregate_state});
     }
     default: {
       return cgen_state_->ir_builder_.CreateLoad(aggregate_state);
     }
   }
 }

Here is the call graph for this function:

void Executor::codegenJoinLoops	(	const std::vector< JoinLoop > &	join_loops,
		const RelAlgExecutionUnit &	ra_exe_unit,
		GroupByAndAggregate &	group_by_and_aggregate,
		llvm::Function *	query_func,
		llvm::BasicBlock *	entry_bb,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo
	)

private

Definition at line 459 of file IRCodegen.cpp.

References JoinLoop::codegen(), CompilationOptions::device_type_, CodeGenerator::posArg(), and ExecutionOptions::with_dynamic_watchdog.

                                                             {
   const auto exit_bb =
       llvm::BasicBlock::Create(cgen_state_->context_, "exit", cgen_state_->row_func_);
   cgen_state_->ir_builder_.SetInsertPoint(exit_bb);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt<int32_t>(0));
   cgen_state_->ir_builder_.SetInsertPoint(entry_bb);
   CodeGenerator code_generator(this);
   const auto loops_entry_bb = JoinLoop::codegen(
       join_loops,
       [this,
        query_func,
        &query_mem_desc,
        &co,
        &eo,
        &group_by_and_aggregate,
        &join_loops,
        &ra_exe_unit](const std::vector<llvm::Value*>& prev_iters) {
         addJoinLoopIterator(prev_iters, join_loops.size());
         auto& builder = cgen_state_->ir_builder_;
         const auto loop_body_bb = llvm::BasicBlock::Create(
             builder.getContext(), "loop_body", builder.GetInsertBlock()->getParent());
         builder.SetInsertPoint(loop_body_bb);
         const bool can_return_error =
             compileBody(ra_exe_unit, group_by_and_aggregate, query_mem_desc, co);
         if (can_return_error || cgen_state_->needs_error_check_ ||
             eo.with_dynamic_watchdog) {
           createErrorCheckControlFlow(
               query_func, eo.with_dynamic_watchdog, co.device_type_);
         }
         return loop_body_bb;
       },
       code_generator.posArg(nullptr),
       exit_bb,
       cgen_state_->ir_builder_);
   cgen_state_->ir_builder_.SetInsertPoint(entry_bb);
   cgen_state_->ir_builder_.CreateBr(loops_entry_bb);
 }

Here is the call graph for this function:

llvm::BasicBlock * Executor::codegenSkipDeletedOuterTableRow	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationOptions &	co
	)

private

Definition at line 1814 of file NativeCodegen.cpp.

                                   {
   CHECK(!ra_exe_unit.input_descs.empty());
   const auto& outer_input_desc = ra_exe_unit.input_descs[0];
   if (outer_input_desc.getSourceType() != InputSourceType::TABLE) {
     return nullptr;
   }
   const auto td = catalog_->getMetadataForTable(outer_input_desc.getTableId());
   CHECK(td);
   const auto deleted_cd = catalog_->getDeletedColumnIfRowsDeleted(td);
   if (!deleted_cd) {
     return nullptr;
   }
   CHECK(deleted_cd->columnType.is_boolean());
   const auto deleted_expr =
       makeExpr<Analyzer::ColumnVar>(deleted_cd->columnType,
                                     outer_input_desc.getTableId(),
                                     deleted_cd->columnId,
                                     outer_input_desc.getNestLevel());
   CodeGenerator code_generator(this);
   const auto is_deleted =
       code_generator.toBool(code_generator.codegen(deleted_expr.get(), true, co).front());
   const auto is_deleted_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "is_deleted", cgen_state_->row_func_);
   llvm::BasicBlock* bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "is_not_deleted", cgen_state_->row_func_);
   cgen_state_->ir_builder_.CreateCondBr(is_deleted, is_deleted_bb, bb);
   cgen_state_->ir_builder_.SetInsertPoint(is_deleted_bb);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt<int32_t>(0));
   cgen_state_->ir_builder_.SetInsertPoint(bb);
   return bb;
 }

void Executor::codegenWindowAvgEpilogue	(	llvm::Value *	crt_val,
		llvm::Value *	window_func_null_val,
		llvm::Value *	multiplicity_lv
	)

private

Definition at line 282 of file WindowFunctionIR.cpp.

References anonymous_namespace{WindowFunctionIR.cpp}::get_adjusted_window_type_info(), get_int_type(), WindowProjectNodeContext::getActiveWindowFunctionContext(), kDOUBLE, and kFLOAT.

                                                                     {
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto window_func = window_func_context->getWindowFunction();
   const auto window_func_ti = get_adjusted_window_type_info(window_func);
   const auto pi32_type =
       llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0);
   const auto pi64_type =
       llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0);
   const auto aggregate_state_type =
       window_func_ti.get_type() == kFLOAT ? pi32_type : pi64_type;
   const auto aggregate_state_count_i64 = cgen_state_->llInt(
       reinterpret_cast<const int64_t>(window_func_context->aggregateStateCount()));
   auto aggregate_state_count = cgen_state_->ir_builder_.CreateIntToPtr(
       aggregate_state_count_i64, aggregate_state_type);
   std::string agg_count_func_name = "agg_count";
   switch (window_func_ti.get_type()) {
     case kFLOAT: {
       agg_count_func_name += "_float";
       break;
     }
     case kDOUBLE: {
       agg_count_func_name += "_double";
       break;
     }
     default: {
       break;
     }
   }
   agg_count_func_name += "_skip_val";
   cgen_state_->emitCall(agg_count_func_name,
                         {aggregate_state_count, crt_val, window_func_null_val});
 }

Here is the call graph for this function:

llvm::Value * Executor::codegenWindowFunction	(	const size_t	target_index,
		const CompilationOptions &	co
	)

private

Definition at line 21 of file WindowFunctionIR.cpp.

References WindowProjectNodeContext::activateWindowFunctionContext(), run_benchmark_import::args, AVG, CHECK(), CHECK_EQ, CodeGenerator::codegen(), COUNT, CUME_DIST, DENSE_RANK, logger::FATAL, FIRST_VALUE, WindowProjectNodeContext::get(), WindowFunctionContext::getWindowFunction(), LAG, LAST_VALUE, LEAD, LOG, MAX, MIN, NTILE, PERCENT_RANK, CodeGenerator::posArg(), RANK, ROW_NUMBER, and SUM.

                                                                            {
   CodeGenerator code_generator(this);
   const auto window_func_context =
       WindowProjectNodeContext::get()->activateWindowFunctionContext(target_index);
   const auto window_func = window_func_context->getWindowFunction();
   switch (window_func->getKind()) {
     case SqlWindowFunctionKind::ROW_NUMBER:
     case SqlWindowFunctionKind::RANK:
     case SqlWindowFunctionKind::DENSE_RANK:
     case SqlWindowFunctionKind::NTILE: {
       return cgen_state_->emitCall("row_number_window_func",
                                    {cgen_state_->llInt(reinterpret_cast<const int64_t>(
                                         window_func_context->output())),
                                     code_generator.posArg(nullptr)});
     }
     case SqlWindowFunctionKind::PERCENT_RANK:
     case SqlWindowFunctionKind::CUME_DIST: {
       return cgen_state_->emitCall("percent_window_func",
                                    {cgen_state_->llInt(reinterpret_cast<const int64_t>(
                                         window_func_context->output())),
                                     code_generator.posArg(nullptr)});
     }
     case SqlWindowFunctionKind::LAG:
     case SqlWindowFunctionKind::LEAD:
     case SqlWindowFunctionKind::FIRST_VALUE:
     case SqlWindowFunctionKind::LAST_VALUE: {
       CHECK(WindowProjectNodeContext::get());
       const auto& args = window_func->getArgs();
       CHECK(!args.empty());
       const auto arg_lvs = code_generator.codegen(args.front().get(), true, co);
       CHECK_EQ(arg_lvs.size(), size_t(1));
       return arg_lvs.front();
     }
     case SqlWindowFunctionKind::AVG:
     case SqlWindowFunctionKind::MIN:
     case SqlWindowFunctionKind::MAX:
     case SqlWindowFunctionKind::SUM:
     case SqlWindowFunctionKind::COUNT: {
       return codegenWindowFunctionAggregate(co);
     }
     default: {
       LOG(FATAL) << "Invalid window function kind";
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * Executor::codegenWindowFunctionAggregate ( const CompilationOptions & co )

private

Definition at line 137 of file WindowFunctionIR.cpp.

References AVG, CHECK(), WindowProjectNodeContext::get(), get_int_type(), and WindowProjectNodeContext::getActiveWindowFunctionContext().

                                                                                 {
   const auto reset_state_false_bb = codegenWindowResetStateControlFlow();
   auto aggregate_state = aggregateWindowStatePtr();
   llvm::Value* aggregate_state_count = nullptr;
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto window_func = window_func_context->getWindowFunction();
   if (window_func->getKind() == SqlWindowFunctionKind::AVG) {
     const auto aggregate_state_count_i64 = cgen_state_->llInt(
         reinterpret_cast<const int64_t>(window_func_context->aggregateStateCount()));
     const auto pi64_type =
         llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0);
     aggregate_state_count =
         cgen_state_->ir_builder_.CreateIntToPtr(aggregate_state_count_i64, pi64_type);
   }
   codegenWindowFunctionStateInit(aggregate_state);
   if (window_func->getKind() == SqlWindowFunctionKind::AVG) {
     const auto count_zero = cgen_state_->llInt(int64_t(0));
     cgen_state_->emitCall("agg_id", {aggregate_state_count, count_zero});
   }
   cgen_state_->ir_builder_.CreateBr(reset_state_false_bb);
   cgen_state_->ir_builder_.SetInsertPoint(reset_state_false_bb);
   CHECK(WindowProjectNodeContext::get());
   return codegenWindowFunctionAggregateCalls(aggregate_state, co);
 }

Here is the call graph for this function:

llvm::Value * Executor::codegenWindowFunctionAggregateCalls	(	llvm::Value *	aggregate_state,
		const CompilationOptions &	co
	)

private

Definition at line 240 of file WindowFunctionIR.cpp.

References run_benchmark_import::args, AVG, CHECK(), CHECK_EQ, CodeGenerator::codegen(), CodeGenerator::codegenCastBetweenIntTypes(), COUNT, anonymous_namespace{WindowFunctionIR.cpp}::get_adjusted_window_type_info(), anonymous_namespace{WindowFunctionIR.cpp}::get_window_agg_name(), WindowProjectNodeContext::getActiveWindowFunctionContext(), kFLOAT, and SUM.

                                                                                          {
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto window_func = window_func_context->getWindowFunction();
   const auto window_func_ti = get_adjusted_window_type_info(window_func);
   const auto window_func_null_val =
       window_func_ti.is_fp()
           ? cgen_state_->inlineFpNull(window_func_ti)
           : cgen_state_->castToTypeIn(cgen_state_->inlineIntNull(window_func_ti), 64);
   const auto& args = window_func->getArgs();
   llvm::Value* crt_val;
   if (args.empty()) {
     CHECK(window_func->getKind() == SqlWindowFunctionKind::COUNT);
     crt_val = cgen_state_->llInt(int64_t(1));
   } else {
     CodeGenerator code_generator(this);
     const auto arg_lvs = code_generator.codegen(args.front().get(), true, co);
     CHECK_EQ(arg_lvs.size(), size_t(1));
     if (window_func->getKind() == SqlWindowFunctionKind::SUM && !window_func_ti.is_fp()) {
       crt_val = code_generator.codegenCastBetweenIntTypes(
           arg_lvs.front(), args.front()->get_type_info(), window_func_ti, false);
     } else {
       crt_val = window_func_ti.get_type() == kFLOAT
                     ? arg_lvs.front()
                     : cgen_state_->castToTypeIn(arg_lvs.front(), 64);
     }
   }
   const auto agg_name = get_window_agg_name(window_func->getKind(), window_func_ti);
   llvm::Value* multiplicity_lv = nullptr;
   if (args.empty()) {
     cgen_state_->emitCall(agg_name, {aggregate_state, crt_val});
   } else {
     cgen_state_->emitCall(agg_name + "_skip_val",
                           {aggregate_state, crt_val, window_func_null_val});
   }
   if (window_func->getKind() == SqlWindowFunctionKind::AVG) {
     codegenWindowAvgEpilogue(crt_val, window_func_null_val, multiplicity_lv);
   }
   return codegenAggregateWindowState();
 }

Here is the call graph for this function:

void Executor::codegenWindowFunctionStateInit ( llvm::Value * aggregate_state )

private

Definition at line 191 of file WindowFunctionIR.cpp.

References COUNT, anonymous_namespace{WindowFunctionIR.cpp}::get_adjusted_window_type_info(), get_int_type(), WindowProjectNodeContext::getActiveWindowFunctionContext(), kDOUBLE, and kFLOAT.

                                                                         {
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto window_func = window_func_context->getWindowFunction();
   const auto window_func_ti = get_adjusted_window_type_info(window_func);
   const auto window_func_null_val =
       window_func_ti.is_fp()
           ? cgen_state_->inlineFpNull(window_func_ti)
           : cgen_state_->castToTypeIn(cgen_state_->inlineIntNull(window_func_ti), 64);
   llvm::Value* window_func_init_val;
   if (window_func_context->getWindowFunction()->getKind() ==
       SqlWindowFunctionKind::COUNT) {
     switch (window_func_ti.get_type()) {
       case kFLOAT: {
         window_func_init_val = cgen_state_->llFp(float(0));
         break;
       }
       case kDOUBLE: {
         window_func_init_val = cgen_state_->llFp(double(0));
         break;
       }
       default: {
         window_func_init_val = cgen_state_->llInt(int64_t(0));
         break;
       }
     }
   } else {
     window_func_init_val = window_func_null_val;
   }
   const auto pi32_type =
       llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0);
   switch (window_func_ti.get_type()) {
     case kDOUBLE: {
       cgen_state_->emitCall("agg_id_double", {aggregate_state, window_func_init_val});
       break;
     }
     case kFLOAT: {
       aggregate_state =
           cgen_state_->ir_builder_.CreateBitCast(aggregate_state, pi32_type);
       cgen_state_->emitCall("agg_id_float", {aggregate_state, window_func_init_val});
       break;
     }
     default: {
       cgen_state_->emitCall("agg_id", {aggregate_state, window_func_init_val});
       break;
     }
   }
 }

Here is the call graph for this function:

llvm::BasicBlock * Executor::codegenWindowResetStateControlFlow ( )

private

Definition at line 163 of file WindowFunctionIR.cpp.

References WindowProjectNodeContext::getActiveWindowFunctionContext(), CodeGenerator::posArg(), and CodeGenerator::toBool().

                                                              {
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext();
   const auto bitset = cgen_state_->llInt(
       reinterpret_cast<const int64_t>(window_func_context->partitionStart()));
   const auto min_val = cgen_state_->llInt(int64_t(0));
   const auto max_val = cgen_state_->llInt(window_func_context->elementCount() - 1);
   const auto null_val = cgen_state_->llInt(inline_int_null_value<int64_t>());
   const auto null_bool_val = cgen_state_->llInt<int8_t>(inline_int_null_value<int8_t>());
   CodeGenerator code_generator(this);
   const auto reset_state =
       code_generator.toBool(cgen_state_->emitCall("bit_is_set",
                                                   {bitset,
                                                    code_generator.posArg(nullptr),
                                                    min_val,
                                                    max_val,
                                                    null_val,
                                                    null_bool_val}));
   const auto reset_state_true_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "reset_state.true", cgen_state_->row_func_);
   const auto reset_state_false_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "reset_state.false", cgen_state_->row_func_);
   cgen_state_->ir_builder_.CreateCondBr(
       reset_state, reset_state_true_bb, reset_state_false_bb);
   cgen_state_->ir_builder_.SetInsertPoint(reset_state_true_bb);
   return reset_state_false_bb;
 }

Here is the call graph for this function:

ResultSetPtr Executor::collectAllDeviceResults	(	ExecutionDispatch &	execution_dispatch,
		const std::vector< Analyzer::Expr * > &	target_exprs,
		const QueryMemoryDescriptor &	query_mem_desc,
		const ExecutorDeviceType	device_type,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner
	)

private

Definition at line 1507 of file Execute.cpp.

References anonymous_namespace{Execute.cpp}::build_row_for_empty_input(), catalog_(), DEBUG_TIMER, Executor::ExecutionDispatch::getExecutionUnit(), Executor::ExecutionDispatch::getFragmentResults(), QueryMemoryDescriptor::getQueryDescriptionType(), GPU, NonGroupedAggregate, GroupByAndAggregate::shard_count_for_top_groups(), and use_speculative_top_n().

                                                         {
   auto timer = DEBUG_TIMER(__func__);
   auto& result_per_device = execution_dispatch.getFragmentResults();
   if (result_per_device.empty() && query_mem_desc.getQueryDescriptionType() ==
                                        QueryDescriptionType::NonGroupedAggregate) {
     return build_row_for_empty_input(target_exprs, query_mem_desc, device_type);
   }
   const auto& ra_exe_unit = execution_dispatch.getExecutionUnit();
   if (use_speculative_top_n(ra_exe_unit, query_mem_desc)) {
     return reduceSpeculativeTopN(
         ra_exe_unit, result_per_device, row_set_mem_owner, query_mem_desc);
   }
   const auto shard_count =
       device_type == ExecutorDeviceType::GPU
           ? GroupByAndAggregate::shard_count_for_top_groups(ra_exe_unit, *catalog_)
           : 0;
 
   if (shard_count && !result_per_device.empty()) {
     return collectAllDeviceShardedTopResults(execution_dispatch);
   }
   return reduceMultiDeviceResults(
       ra_exe_unit, result_per_device, row_set_mem_owner, query_mem_desc);
 }

Here is the call graph for this function:

ResultSetPtr Executor::collectAllDeviceShardedTopResults ( ExecutionDispatch & execution_dispatch ) const

private

Definition at line 1618 of file Execute.cpp.

References CHECK(), CHECK_EQ, CHECK_LE, Executor::ExecutionDispatch::getExecutionUnit(), Executor::ExecutionDispatch::getFragmentResults(), anonymous_namespace{Execute.cpp}::permute_storage_columnar(), anonymous_namespace{Execute.cpp}::permute_storage_row_wise(), and run_benchmark_import::result.

                                                  {
   const auto& ra_exe_unit = execution_dispatch.getExecutionUnit();
   auto& result_per_device = execution_dispatch.getFragmentResults();
   const auto first_result_set = result_per_device.front().first;
   CHECK(first_result_set);
   auto top_query_mem_desc = first_result_set->getQueryMemDesc();
   CHECK(!top_query_mem_desc.hasInterleavedBinsOnGpu());
   const auto top_n = ra_exe_unit.sort_info.limit + ra_exe_unit.sort_info.offset;
   top_query_mem_desc.setEntryCount(0);
   for (auto& result : result_per_device) {
     const auto result_set = result.first;
     CHECK(result_set);
     result_set->sort(ra_exe_unit.sort_info.order_entries, top_n);
     size_t new_entry_cnt = top_query_mem_desc.getEntryCount() + result_set->rowCount();
     top_query_mem_desc.setEntryCount(new_entry_cnt);
   }
   auto top_result_set = std::make_shared<ResultSet>(first_result_set->getTargetInfos(),
                                                     first_result_set->getDeviceType(),
                                                     top_query_mem_desc,
                                                     first_result_set->getRowSetMemOwner(),
                                                     this);
   auto top_storage = top_result_set->allocateStorage();
   size_t top_output_row_idx{0};
   for (auto& result : result_per_device) {
     const auto result_set = result.first;
     CHECK(result_set);
     const auto& top_permutation = result_set->getPermutationBuffer();
     CHECK_LE(top_permutation.size(), top_n);
     if (top_query_mem_desc.didOutputColumnar()) {
       top_output_row_idx = permute_storage_columnar(result_set->getStorage(),
                                                     result_set->getQueryMemDesc(),
                                                     top_storage,
                                                     top_output_row_idx,
                                                     top_query_mem_desc,
                                                     top_permutation);
     } else {
       top_output_row_idx = permute_storage_row_wise(result_set->getStorage(),
                                                     top_storage,
                                                     top_output_row_idx,
                                                     top_query_mem_desc,
                                                     top_permutation);
     }
   }
   CHECK_EQ(top_output_row_idx, top_query_mem_desc.getEntryCount());
   return top_result_set;
 }

Here is the call graph for this function:

bool Executor::compileBody	(	const RelAlgExecutionUnit &	ra_exe_unit,
		GroupByAndAggregate &	group_by_and_aggregate,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co
	)

private

Definition at line 1848 of file NativeCodegen.cpp.

                                                          {
   // generate the code for the filter
   std::vector<Analyzer::Expr*> primary_quals;
   std::vector<Analyzer::Expr*> deferred_quals;
   bool short_circuited =
       CodeGenerator::prioritizeQuals(ra_exe_unit, primary_quals, deferred_quals);
   if (short_circuited) {
     VLOG(1) << "Prioritized " << std::to_string(primary_quals.size()) << " quals, "
             << "short-circuited and deferred " << std::to_string(deferred_quals.size())
             << " quals";
   }
   llvm::Value* filter_lv = cgen_state_->llBool(true);
   CodeGenerator code_generator(this);
   for (auto expr : primary_quals) {
     // Generate the filter for primary quals
     auto cond = code_generator.toBool(code_generator.codegen(expr, true, co).front());
     filter_lv = cgen_state_->ir_builder_.CreateAnd(filter_lv, cond);
   }
   CHECK(filter_lv->getType()->isIntegerTy(1));
   llvm::BasicBlock* sc_false{nullptr};
   if (!deferred_quals.empty()) {
     auto sc_true = llvm::BasicBlock::Create(
         cgen_state_->context_, "sc_true", cgen_state_->row_func_);
     sc_false = llvm::BasicBlock::Create(
         cgen_state_->context_, "sc_false", cgen_state_->row_func_);
     cgen_state_->ir_builder_.CreateCondBr(filter_lv, sc_true, sc_false);
     cgen_state_->ir_builder_.SetInsertPoint(sc_false);
     if (ra_exe_unit.join_quals.empty()) {
       cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt(int32_t(0)));
     }
     cgen_state_->ir_builder_.SetInsertPoint(sc_true);
     filter_lv = cgen_state_->llBool(true);
   }
   for (auto expr : deferred_quals) {
     filter_lv = cgen_state_->ir_builder_.CreateAnd(
         filter_lv, code_generator.toBool(code_generator.codegen(expr, true, co).front()));
   }
 
   CHECK(filter_lv->getType()->isIntegerTy(1));
   return group_by_and_aggregate.codegen(filter_lv, sc_false, query_mem_desc, co);
 }

std::tuple< Executor::CompilationResult, std::unique_ptr< QueryMemoryDescriptor > > Executor::compileWorkUnit	(	const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo,
		const CudaMgr_Namespace::CudaMgr *	cuda_mgr,
		const bool	allow_lazy_fetch,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const size_t	max_groups_buffer_entry_count,
		const int8_t	crt_min_byte_width,
		const bool	has_cardinality_estimation,
		ColumnCacheMap &	column_cache,
		RenderInfo *	render_info = `nullptr`
	)

private

Definition at line 1568 of file NativeCodegen.cpp.

                                                    {
   auto timer = DEBUG_TIMER(__func__);
   nukeOldState(allow_lazy_fetch, query_infos, &ra_exe_unit);
 
   GroupByAndAggregate group_by_and_aggregate(
       this, co.device_type_, ra_exe_unit, query_infos, row_set_mem_owner);
   auto query_mem_desc =
       group_by_and_aggregate.initQueryMemoryDescriptor(eo.allow_multifrag,
                                                        max_groups_buffer_entry_guess,
                                                        crt_min_byte_width,
                                                        render_info,
                                                        eo.output_columnar_hint);
 
   if (query_mem_desc->getQueryDescriptionType() ==
           QueryDescriptionType::GroupByBaselineHash &&
       !has_cardinality_estimation &&
       (!render_info || !render_info->isPotentialInSituRender()) && !eo.just_explain) {
     throw CardinalityEstimationRequired();
   }
 
   const bool output_columnar = query_mem_desc->didOutputColumnar();
 
   if (co.device_type_ == ExecutorDeviceType::GPU) {
     const size_t num_count_distinct_descs =
         query_mem_desc->getCountDistinctDescriptorsSize();
     for (size_t i = 0; i < num_count_distinct_descs; i++) {
       const auto& count_distinct_descriptor =
           query_mem_desc->getCountDistinctDescriptor(i);
       if (count_distinct_descriptor.impl_type_ == CountDistinctImplType::StdSet ||
           (count_distinct_descriptor.impl_type_ != CountDistinctImplType::Invalid &&
            !co.hoist_literals_)) {
         throw QueryMustRunOnCpu();
       }
     }
   }
 
   // Read the module template and target either CPU or GPU
   // by binding the stream position functions to the right implementation:
   // stride access for GPU, contiguous for CPU
   auto rt_module_copy = llvm::CloneModule(
 #if LLVM_VERSION_MAJOR >= 7
       *g_rt_module.get(),
 #else
       g_rt_module.get(),
 #endif
       cgen_state_->vmap_,
       [](const llvm::GlobalValue* gv) {
         auto func = llvm::dyn_cast<llvm::Function>(gv);
         if (!func) {
           return true;
         }
         return (func->getLinkage() == llvm::GlobalValue::LinkageTypes::PrivateLinkage ||
                 func->getLinkage() == llvm::GlobalValue::LinkageTypes::InternalLinkage ||
                 CodeGenerator::alwaysCloneRuntimeFunction(func));
       });
 
   if (co.device_type_ == ExecutorDeviceType::CPU) {
     if (is_udf_module_present(true)) {
       CodeGenerator::link_udf_module(udf_cpu_module, *rt_module_copy, cgen_state_.get());
     }
     if (is_rt_udf_module_present(true)) {
       CodeGenerator::link_udf_module(
           rt_udf_cpu_module, *rt_module_copy, cgen_state_.get());
     }
   } else {
     rt_module_copy->setDataLayout(get_gpu_data_layout());
     rt_module_copy->setTargetTriple(get_gpu_target_triple_string());
 
     if (is_udf_module_present()) {
       llvm::Triple gpu_triple(udf_gpu_module->getTargetTriple());
 
       if (!gpu_triple.isNVPTX()) {
         throw QueryMustRunOnCpu();
       }
 
       CodeGenerator::link_udf_module(udf_gpu_module, *rt_module_copy, cgen_state_.get());
     }
     if (is_rt_udf_module_present()) {
       CodeGenerator::link_udf_module(
           rt_udf_gpu_module, *rt_module_copy, cgen_state_.get());
     }
   }
 
   cgen_state_->module_ = rt_module_copy.release();
 
   auto agg_fnames =
       get_agg_fnames(ra_exe_unit.target_exprs, !ra_exe_unit.groupby_exprs.empty());
 
   const auto agg_slot_count = ra_exe_unit.estimator ? size_t(1) : agg_fnames.size();
 
   const bool is_group_by{query_mem_desc->isGroupBy()};
   auto query_func = is_group_by ? query_group_by_template(cgen_state_->module_,
                                                           co.hoist_literals_,
                                                           *query_mem_desc,
                                                           co.device_type_,
                                                           ra_exe_unit.scan_limit)
                                 : query_template(cgen_state_->module_,
                                                  agg_slot_count,
                                                  co.hoist_literals_,
                                                  !!ra_exe_unit.estimator);
   bind_pos_placeholders("pos_start", true, query_func, cgen_state_->module_);
   bind_pos_placeholders("group_buff_idx", false, query_func, cgen_state_->module_);
   bind_pos_placeholders("pos_step", false, query_func, cgen_state_->module_);
 
   cgen_state_->query_func_ = query_func;
   cgen_state_->query_func_entry_ir_builder_.SetInsertPoint(
       &query_func->getEntryBlock().front());
 
   std::vector<llvm::Value*> col_heads;
   std::tie(cgen_state_->row_func_, col_heads) =
       create_row_function(ra_exe_unit.input_col_descs.size(),
                           is_group_by ? 0 : agg_slot_count,
                           co.hoist_literals_,
                           query_func,
                           cgen_state_->module_,
                           cgen_state_->context_);
   CHECK(cgen_state_->row_func_);
   // make sure it's in-lined, we don't want register spills in the inner loop
   mark_function_always_inline(cgen_state_->row_func_);
   auto bb =
       llvm::BasicBlock::Create(cgen_state_->context_, "entry", cgen_state_->row_func_);
   cgen_state_->ir_builder_.SetInsertPoint(bb);
   preloadFragOffsets(ra_exe_unit.input_descs, query_infos);
   RelAlgExecutionUnit body_execution_unit = ra_exe_unit;
   const auto join_loops =
       buildJoinLoops(body_execution_unit, co, eo, query_infos, column_cache);
   plan_state_->allocateLocalColumnIds(ra_exe_unit.input_col_descs);
   const auto is_not_deleted_bb = codegenSkipDeletedOuterTableRow(ra_exe_unit, co);
   if (is_not_deleted_bb) {
     bb = is_not_deleted_bb;
   }
   if (!join_loops.empty()) {
     codegenJoinLoops(join_loops,
                      body_execution_unit,
                      group_by_and_aggregate,
                      query_func,
                      bb,
                      *(query_mem_desc.get()),
                      co,
                      eo);
   } else {
     const bool can_return_error =
         compileBody(ra_exe_unit, group_by_and_aggregate, *query_mem_desc, co);
     if (can_return_error || cgen_state_->needs_error_check_ || eo.with_dynamic_watchdog) {
       createErrorCheckControlFlow(query_func, eo.with_dynamic_watchdog, co.device_type_);
     }
   }
   std::vector<llvm::Value*> hoisted_literals;
 
   if (co.hoist_literals_) {
     VLOG(1) << "number of hoisted literals: "
             << cgen_state_->query_func_literal_loads_.size()
             << " / literal buffer usage: " << cgen_state_->getLiteralBufferUsage(0)
             << " bytes";
   }
 
   if (co.hoist_literals_ && !cgen_state_->query_func_literal_loads_.empty()) {
     // we have some hoisted literals...
     hoisted_literals = inlineHoistedLiterals();
   }
   // iterate through all the instruction in the query template function and
   // replace the call to the filter placeholder with the call to the actual filter
   for (auto it = llvm::inst_begin(query_func), e = llvm::inst_end(query_func); it != e;
        ++it) {
     if (!llvm::isa<llvm::CallInst>(*it)) {
       continue;
     }
     auto& filter_call = llvm::cast<llvm::CallInst>(*it);
     if (std::string(filter_call.getCalledFunction()->getName()) == "row_process") {
       std::vector<llvm::Value*> args;
       for (size_t i = 0; i < filter_call.getNumArgOperands(); ++i) {
         args.push_back(filter_call.getArgOperand(i));
       }
       args.insert(args.end(), col_heads.begin(), col_heads.end());
       args.push_back(get_arg_by_name(query_func, "join_hash_tables"));
       // push hoisted literals arguments, if any
       args.insert(args.end(), hoisted_literals.begin(), hoisted_literals.end());
 
       llvm::ReplaceInstWithInst(&filter_call,
                                 llvm::CallInst::Create(cgen_state_->row_func_, args, ""));
       break;
     }
   }
   plan_state_->init_agg_vals_ =
       init_agg_val_vec(ra_exe_unit.target_exprs, ra_exe_unit.quals, *query_mem_desc);
 
   auto multifrag_query_func = cgen_state_->module_->getFunction(
       "multifrag_query" + std::string(co.hoist_literals_ ? "_hoisted_literals" : ""));
   CHECK(multifrag_query_func);
 
   bind_query(query_func,
              "query_stub" + std::string(co.hoist_literals_ ? "_hoisted_literals" : ""),
              multifrag_query_func,
              cgen_state_->module_);
 
   auto live_funcs =
       CodeGenerator::markDeadRuntimeFuncs(*cgen_state_->module_,
                                           {query_func, cgen_state_->row_func_},
                                           {multifrag_query_func});
 
   std::string llvm_ir;
   if (eo.just_explain) {
     if (co.explain_type_ == ExecutorExplainType::Optimized) {
 #ifdef WITH_JIT_DEBUG
       throw std::runtime_error(
           "Explain optimized not available when JIT runtime debug symbols are enabled");
 #else
       optimize_ir(query_func, cgen_state_->module_, live_funcs, co);
 #endif  // WITH_JIT_DEBUG
     }
     llvm_ir =
         serialize_llvm_object(query_func) + serialize_llvm_object(cgen_state_->row_func_);
   }
   verify_function_ir(cgen_state_->row_func_);
 
   LOG(IR) << query_mem_desc->toString() << "\nGenerated IR\n"
           << serialize_llvm_object(query_func)
           << serialize_llvm_object(cgen_state_->row_func_) << "\nEnd of IR";
 
   return std::make_tuple(
       Executor::CompilationResult{
           co.device_type_ == ExecutorDeviceType::CPU
               ? optimizeAndCodegenCPU(query_func, multifrag_query_func, live_funcs, co)
               : optimizeAndCodegenGPU(query_func,
                                       multifrag_query_func,
                                       live_funcs,
                                       is_group_by || ra_exe_unit.estimator,
                                       cuda_mgr,
                                       co),
           cgen_state_->getLiterals(),
           output_columnar,
           llvm_ir},
       std::move(query_mem_desc));
 }

AggregatedColRange Executor::computeColRangesCache ( const std::unordered_set< PhysicalInput > & phys_inputs )

private

Definition at line 3244 of file Execute.cpp.

References catalog_(), CHECK(), getLeafColumnRange(), AggregatedColRange::setColRange(), and ExpressionRange::typeSupportsRange().

                                                         {
   AggregatedColRange agg_col_range_cache;
   CHECK(catalog_);
   std::unordered_set<int> phys_table_ids;
   for (const auto& phys_input : phys_inputs) {
     phys_table_ids.insert(phys_input.table_id);
   }
   std::vector<InputTableInfo> query_infos;
   for (const int table_id : phys_table_ids) {
     query_infos.emplace_back(InputTableInfo{table_id, getTableInfo(table_id)});
   }
   for (const auto& phys_input : phys_inputs) {
     const auto cd =
         catalog_->getMetadataForColumn(phys_input.table_id, phys_input.col_id);
     CHECK(cd);
     if (ExpressionRange::typeSupportsRange(cd->columnType)) {
       const auto col_var = boost::make_unique<Analyzer::ColumnVar>(
           cd->columnType, phys_input.table_id, phys_input.col_id, 0);
       const auto col_range = getLeafColumnRange(col_var.get(), query_infos, this, false);
       agg_col_range_cache.setColRange(phys_input, col_range);
     }
   }
   return agg_col_range_cache;
 }

Here is the call graph for this function:

StringDictionaryGenerations Executor::computeStringDictionaryGenerations ( const std::unordered_set< PhysicalInput > & phys_inputs )

private

Definition at line 3270 of file Execute.cpp.

References catalog_(), CHECK(), kENCODING_DICT, and StringDictionaryGenerations::setGeneration().

                                                         {
   StringDictionaryGenerations string_dictionary_generations;
   CHECK(catalog_);
   for (const auto& phys_input : phys_inputs) {
     const auto cd =
         catalog_->getMetadataForColumn(phys_input.table_id, phys_input.col_id);
     CHECK(cd);
     const auto& col_ti =
         cd->columnType.is_array() ? cd->columnType.get_elem_type() : cd->columnType;
     if (col_ti.is_string() && col_ti.get_compression() == kENCODING_DICT) {
       const int dict_id = col_ti.get_comp_param();
       const auto dd = catalog_->getMetadataForDict(dict_id);
       CHECK(dd && dd->stringDict);
       string_dictionary_generations.setGeneration(dict_id,
                                                   dd->stringDict->storageEntryCount());
     }
   }
   return string_dictionary_generations;
 }

Here is the call graph for this function:

TableGenerations Executor::computeTableGenerations ( std::unordered_set< int > phys_table_ids )

private

Definition at line 3291 of file Execute.cpp.

References TableGenerations::setGeneration().

                                           {
   TableGenerations table_generations;
   for (const int table_id : phys_table_ids) {
     const auto table_info = getTableInfo(table_id);
     table_generations.setGeneration(
         table_id, TableGeneration{table_info.getPhysicalNumTuples(), 0});
   }
   return table_generations;
 }

Here is the call graph for this function:

bool Executor::containsLeftDeepOuterJoin ( ) const

inline

Definition at line 436 of file Execute.h.

References cgen_state_.

                                          {
     return cgen_state_->contains_left_deep_outer_join_;
   }

void Executor::createErrorCheckControlFlow	(	llvm::Function *	query_func,
		bool	run_with_dynamic_watchdog,
		ExecutorDeviceType	device_type
	)

private

Definition at line 1343 of file NativeCodegen.cpp.

                                                                            {
   // check whether the row processing was successful; currently, it can
   // fail by running out of group by buffer slots
 
   llvm::Value* row_count = nullptr;
   if (run_with_dynamic_watchdog && device_type == ExecutorDeviceType::GPU) {
     row_count =
         find_variable_in_basic_block<llvm::LoadInst>(query_func, ".entry", "row_count");
   }
 
   bool done_splitting = false;
   for (auto bb_it = query_func->begin(); bb_it != query_func->end() && !done_splitting;
        ++bb_it) {
     llvm::Value* pos = nullptr;
     for (auto inst_it = bb_it->begin(); inst_it != bb_it->end(); ++inst_it) {
       if (run_with_dynamic_watchdog && llvm::isa<llvm::PHINode>(*inst_it)) {
         if (inst_it->getName() == "pos") {
           pos = &*inst_it;
         }
         continue;
       }
       if (!llvm::isa<llvm::CallInst>(*inst_it)) {
         continue;
       }
       auto& filter_call = llvm::cast<llvm::CallInst>(*inst_it);
       if (std::string(filter_call.getCalledFunction()->getName()) == "row_process") {
         auto next_inst_it = inst_it;
         ++next_inst_it;
         auto new_bb = bb_it->splitBasicBlock(next_inst_it);
         auto& br_instr = bb_it->back();
         llvm::IRBuilder<> ir_builder(&br_instr);
         llvm::Value* err_lv = &*inst_it;
         if (run_with_dynamic_watchdog) {
           CHECK(pos);
           llvm::Value* call_watchdog_lv = nullptr;
           if (device_type == ExecutorDeviceType::GPU) {
             // In order to make sure all threads wihtin a block see the same barrier,
             // only those blocks whose none of their threads have experienced the critical
             // edge will go through the dynamic watchdog computation
             CHECK(row_count);
             auto crit_edge_rem =
                 (blockSize() & (blockSize() - 1))
                     ? ir_builder.CreateSRem(
                           row_count,
                           cgen_state_->llInt(static_cast<int64_t>(blockSize())))
                     : ir_builder.CreateAnd(
                           row_count,
                           cgen_state_->llInt(static_cast<int64_t>(blockSize() - 1)));
             auto crit_edge_threshold = ir_builder.CreateSub(row_count, crit_edge_rem);
             crit_edge_threshold->setName("crit_edge_threshold");
 
             // only those threads where pos < crit_edge_threshold go through dynamic
             // watchdog call
             call_watchdog_lv =
                 ir_builder.CreateICmp(llvm::ICmpInst::ICMP_SLT, pos, crit_edge_threshold);
           } else {
             // CPU path: run watchdog for every 64th row
             auto dw_predicate = ir_builder.CreateAnd(pos, uint64_t(0x3f));
             call_watchdog_lv = ir_builder.CreateICmp(
                 llvm::ICmpInst::ICMP_EQ, dw_predicate, cgen_state_->llInt(int64_t(0LL)));
           }
           CHECK(call_watchdog_lv);
           auto error_check_bb = bb_it->splitBasicBlock(
               llvm::BasicBlock::iterator(br_instr), ".error_check");
           auto& watchdog_br_instr = bb_it->back();
 
           auto watchdog_check_bb = llvm::BasicBlock::Create(
               cgen_state_->context_, ".watchdog_check", query_func, error_check_bb);
           llvm::IRBuilder<> watchdog_ir_builder(watchdog_check_bb);
           auto detected_timeout = watchdog_ir_builder.CreateCall(
               cgen_state_->module_->getFunction("dynamic_watchdog"), {});
           auto timeout_err_lv = watchdog_ir_builder.CreateSelect(
               detected_timeout, cgen_state_->llInt(Executor::ERR_OUT_OF_TIME), err_lv);
           watchdog_ir_builder.CreateBr(error_check_bb);
 
           llvm::ReplaceInstWithInst(
               &watchdog_br_instr,
               llvm::BranchInst::Create(
                   watchdog_check_bb, error_check_bb, call_watchdog_lv));
           ir_builder.SetInsertPoint(&br_instr);
           auto unified_err_lv = ir_builder.CreatePHI(err_lv->getType(), 2);
 
           unified_err_lv->addIncoming(timeout_err_lv, watchdog_check_bb);
           unified_err_lv->addIncoming(err_lv, &*bb_it);
           err_lv = unified_err_lv;
         }
         const auto error_code_arg = get_arg_by_name(query_func, "error_code");
         err_lv =
             ir_builder.CreateCall(cgen_state_->module_->getFunction("record_error_code"),
                                   std::vector<llvm::Value*>{err_lv, error_code_arg});
         if (device_type == ExecutorDeviceType::GPU) {
           // let kernel execution finish as expected, regardless of the observed error,
           // unless it is from the dynamic watchdog where all threads within that block
           // return together.
           err_lv = ir_builder.CreateICmp(llvm::ICmpInst::ICMP_EQ,
                                          err_lv,
                                          cgen_state_->llInt(Executor::ERR_OUT_OF_TIME));
         } else {
           err_lv = ir_builder.CreateICmp(llvm::ICmpInst::ICMP_NE,
                                          err_lv,
                                          cgen_state_->llInt(static_cast<int32_t>(0)));
         }
         auto error_bb = llvm::BasicBlock::Create(
             cgen_state_->context_, ".error_exit", query_func, new_bb);
         llvm::ReturnInst::Create(cgen_state_->context_, error_bb);
         llvm::ReplaceInstWithInst(&br_instr,
                                   llvm::BranchInst::Create(error_bb, new_bb, err_lv));
         done_splitting = true;
         break;
       }
     }
   }
   CHECK(done_splitting);
 }

int Executor::deviceCount ( const ExecutorDeviceType device_type ) const

private

Definition at line 597 of file Execute.cpp.

References catalog_(), CHECK(), and GPU.

                                                                     {
   if (device_type == ExecutorDeviceType::GPU) {
     const auto cuda_mgr = catalog_->getDataMgr().getCudaMgr();
     CHECK(cuda_mgr);
     return cuda_mgr->getDeviceCount();
   } else {
     return 1;
   }
 }

Here is the call graph for this function:

int Executor::deviceCountForMemoryLevel ( const Data_Namespace::MemoryLevel memory_level ) const

private

Definition at line 607 of file Execute.cpp.

References CPU, GPU, and Data_Namespace::GPU_LEVEL.

                                                         {
   return memory_level == GPU_LEVEL ? deviceCount(ExecutorDeviceType::GPU)
                                    : deviceCount(ExecutorDeviceType::CPU);
 }

int64_t Executor::deviceCycles ( int milliseconds ) const

private

Definition at line 2976 of file Execute.cpp.

References catalog_(), and CHECK().

                                                      {
   CHECK(catalog_);
   const auto cuda_mgr = catalog_->getDataMgr().getCudaMgr();
   CHECK(cuda_mgr);
   const auto& dev_props = cuda_mgr->getAllDeviceProperties();
   return static_cast<int64_t>(dev_props.front().clockKhz) * milliseconds;
 }

Here is the call graph for this function:

void Executor::dispatchFragments	(	const std::function< void(const ExecutorDeviceType chosen_device_type, int chosen_device_id, 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)>	dispatch,
		const ExecutionDispatch &	execution_dispatch,
		const std::vector< InputTableInfo > &	table_infos,
		const ExecutionOptions &	eo,
		const bool	is_agg,
		const bool	allow_single_frag_table_opt,
		const size_t	context_count,
		const QueryCompilationDescriptor &	query_comp_desc,
		const QueryMemoryDescriptor &	query_mem_desc,
		QueryFragmentDescriptor &	fragment_descriptor,
		std::unordered_set< int > &	available_gpus,
		int &	available_cpus
	)

private

Definition at line 1692 of file Execute.cpp.

References ExecutionOptions::allow_multifrag, QueryFragmentDescriptor::assignFragsToKernelDispatch(), QueryFragmentDescriptor::assignFragsToMultiDispatch(), QueryFragmentDescriptor::buildFragmentKernelMap(), catalog_(), CHECK(), CHECK_GE, CHECK_GT, anonymous_namespace{Execute.cpp}::checkWorkUnitWatchdog(), g_inner_join_fragment_skipping, QueryCompilationDescriptor::getDeviceType(), QueryMemoryDescriptor::getEntryCount(), Executor::ExecutionDispatch::getExecutionUnit(), Executor::ExecutionDispatch::getFragOffsets(), QueryMemoryDescriptor::getQueryDescriptionType(), GPU, anonymous_namespace{Execute.cpp}::has_lazy_fetched_columns(), logger::INFO, KernelPerFragment, LOG, MultifragmentKernel, Projection, query_mem_desc, QueryFragmentDescriptor::shouldCheckWorkUnitWatchdog(), QueryMemoryDescriptor::toString(), VLOG, and ExecutionOptions::with_watchdog.

                          {
   std::vector<std::future<void>> query_threads;
   const auto& ra_exe_unit = execution_dispatch.getExecutionUnit();
   CHECK(!ra_exe_unit.input_descs.empty());
 
   const auto device_type = query_comp_desc.getDeviceType();
   const bool uses_lazy_fetch =
       plan_state_->allow_lazy_fetch_ &&
       has_lazy_fetched_columns(getColLazyFetchInfo(ra_exe_unit.target_exprs));
   const bool use_multifrag_kernel = (device_type == ExecutorDeviceType::GPU) &&
                                     eo.allow_multifrag && (!uses_lazy_fetch || is_agg);
 
   const auto device_count = deviceCount(device_type);
   CHECK_GT(device_count, 0);
 
   fragment_descriptor.buildFragmentKernelMap(ra_exe_unit,
                                              execution_dispatch.getFragOffsets(),
                                              device_count,
                                              device_type,
                                              use_multifrag_kernel,
                                              g_inner_join_fragment_skipping,
                                              this);
   if (eo.with_watchdog && fragment_descriptor.shouldCheckWorkUnitWatchdog()) {
     checkWorkUnitWatchdog(ra_exe_unit, table_infos, *catalog_, device_type, device_count);
   }
 
   if (use_multifrag_kernel) {
     VLOG(1) << "Dispatching multifrag kernels";
     VLOG(1) << query_mem_desc.toString();
 
     // NB: We should never be on this path when the query is retried because of running
     // out of group by slots; also, for scan only queries on CPU we want the
     // high-granularity, fragment by fragment execution instead. For scan only queries on
     // GPU, we want the multifrag kernel path to save the overhead of allocating an output
     // buffer per fragment.
     auto multifrag_kernel_dispatch =
         [&query_threads, &dispatch, query_comp_desc, query_mem_desc](
             const int device_id,
             const FragmentsList& frag_list,
             const int64_t rowid_lookup_key) {
           query_threads.push_back(std::async(std::launch::async,
                                              dispatch,
                                              ExecutorDeviceType::GPU,
                                              device_id,
                                              query_comp_desc,
                                              query_mem_desc,
                                              frag_list,
                                              ExecutorDispatchMode::MultifragmentKernel,
                                              rowid_lookup_key));
         };
     fragment_descriptor.assignFragsToMultiDispatch(multifrag_kernel_dispatch);
   } else {
     VLOG(1) << "Dispatching kernel per fragment";
     VLOG(1) << query_mem_desc.toString();
 
     if (!ra_exe_unit.use_bump_allocator && allow_single_frag_table_opt &&
         (query_mem_desc.getQueryDescriptionType() == QueryDescriptionType::Projection) &&
         table_infos.size() == 1 && table_infos.front().table_id > 0) {
       const auto max_frag_size =
           table_infos.front().info.getFragmentNumTuplesUpperBound();
       if (max_frag_size < query_mem_desc.getEntryCount()) {
         LOG(INFO) << "Lowering scan limit from " << query_mem_desc.getEntryCount()
                   << " to match max fragment size " << max_frag_size
                   << " for kernel per fragment execution path.";
         throw CompilationRetryNewScanLimit(max_frag_size);
       }
     }
 
     size_t frag_list_idx{0};
     auto fragment_per_kernel_dispatch = [&query_threads,
                                          &dispatch,
                                          &frag_list_idx,
                                          &device_type,
                                          query_comp_desc,
                                          query_mem_desc](const int device_id,
                                                          const FragmentsList& frag_list,
                                                          const int64_t rowid_lookup_key) {
       if (!frag_list.size()) {
         return;
       }
       CHECK_GE(device_id, 0);
 
       query_threads.push_back(std::async(std::launch::async,
                                          dispatch,
                                          device_type,
                                          device_id,
                                          query_comp_desc,
                                          query_mem_desc,
                                          frag_list,
                                          ExecutorDispatchMode::KernelPerFragment,
                                          rowid_lookup_key));
 
       ++frag_list_idx;
     };
 
     fragment_descriptor.assignFragsToKernelDispatch(fragment_per_kernel_dispatch,
                                                     ra_exe_unit);
   }
   for (auto& child : query_threads) {
     child.wait();
   }
   for (auto& child : query_threads) {
     child.get();
   }
 }

Here is the call graph for this function:

std::shared_ptr< ResultSet > Executor::execute	(	const Planner::RootPlan *	root_plan,
		const Catalog_Namespace::SessionInfo &	session,
		const bool	hoist_literals,
		const ExecutorDeviceType	device_type,
		const ExecutorOptLevel	opt_level,
		const bool	allow_multifrag,
		const bool	allow_loop_joins,
		RenderInfo *	render_query_data = `nullptr`
	)

Definition at line 32 of file LegacyExecute.cpp.

References catalog_(), CHECK(), CPU, g_enable_dynamic_watchdog, Catalog_Namespace::SessionInfo::get_currentUser(), Planner::RootPlan::get_plan_dest(), Planner::RootPlan::get_result_table_id(), Planner::RootPlan::get_stmt_type(), Catalog_Namespace::SessionInfo::getCatalog(), Planner::RootPlan::getCatalog(), AccessPrivileges::INSERT_INTO_TABLE, Catalog_Namespace::SysCatalog::instance(), Planner::RootPlan::kEXPLAIN, kINSERT, kSELECT, DBObject::loadKey(), DBObject::setPrivileges(), TableDBObjectType, timer_start(), and timer_stop().

                              {
   catalog_ = &root_plan->getCatalog();
   const auto stmt_type = root_plan->get_stmt_type();
   // capture the lock acquistion time
   auto clock_begin = timer_start();
   std::lock_guard<std::mutex> lock(execute_mutex_);
   if (g_enable_dynamic_watchdog) {
     resetInterrupt();
   }
   ScopeGuard restore_metainfo_cache = [this] { clearMetaInfoCache(); };
   int64_t queue_time_ms = timer_stop(clock_begin);
   ScopeGuard row_set_holder = [this] { row_set_mem_owner_ = nullptr; };
   switch (stmt_type) {
     case kSELECT: {
       throw std::runtime_error("The legacy SELECT path has been fully deprecated.");
     }
     case kINSERT: {
       if (root_plan->get_plan_dest() == Planner::RootPlan::kEXPLAIN) {
         auto explanation_rs = std::make_shared<ResultSet>("No explanation available.");
         explanation_rs->setQueueTime(queue_time_ms);
         return explanation_rs;
       }
       auto& cat = session.getCatalog();
       auto& sys_cat = Catalog_Namespace::SysCatalog::instance();
       auto user_metadata = session.get_currentUser();
       const int table_id = root_plan->get_result_table_id();
       auto td = cat.getMetadataForTable(table_id);
       DBObject dbObject(td->tableName, TableDBObjectType);
       dbObject.loadKey(cat);
       dbObject.setPrivileges(AccessPrivileges::INSERT_INTO_TABLE);
       std::vector<DBObject> privObjects;
       privObjects.push_back(dbObject);
       if (!sys_cat.checkPrivileges(user_metadata, privObjects)) {
         throw std::runtime_error(
             "Violation of access privileges: user " + user_metadata.userName +
             " has no insert privileges for table " + td->tableName + ".");
         break;
       }
       executeSimpleInsert(root_plan);
       auto empty_rs = std::make_shared<ResultSet>(std::vector<TargetInfo>{},
                                                   ExecutorDeviceType::CPU,
                                                   QueryMemoryDescriptor(),
                                                   nullptr,
                                                   this);
       empty_rs->setQueueTime(queue_time_ms);
       return empty_rs;
     }
     default:
       CHECK(false);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

ResultSetPtr Executor::executeExplain ( const QueryCompilationDescriptor & query_comp_desc )

private

Definition at line 1372 of file Execute.cpp.

References QueryCompilationDescriptor::getIR().

                                                                                        {
   return std::make_shared<ResultSet>(query_comp_desc.getIR());
 }

Here is the call graph for this function:

int32_t Executor::executePlanWithGroupBy	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationResult &	compilation_result,
		const bool	hoist_literals,
		ResultSetPtr &	results,
		const ExecutorDeviceType	device_type,
		std::vector< std::vector< const int8_t * >> &	col_buffers,
		const std::vector< size_t >	outer_tab_frag_ids,
		QueryExecutionContext *	query_exe_context,
		const std::vector< std::vector< int64_t >> &	num_rows,
		const std::vector< std::vector< uint64_t >> &	frag_offsets,
		Data_Namespace::DataMgr *	data_mgr,
		const int	device_id,
		const int64_t	limit,
		const uint32_t	start_rowid,
		const uint32_t	num_tables,
		RenderInfo *	render_info
	)

private

Definition at line 2402 of file Execute.cpp.

References CHECK(), CHECK_NE, anonymous_namespace{Execute.cpp}::check_rows_less_than_needed(), CPU, DEBUG_TIMER, ERR_DIV_BY_ZERO, ERR_INTERRUPTED, ERR_OUT_OF_TIME, ERR_OVERFLOW_OR_UNDERFLOW, error_code, logger::FATAL, g_enable_dynamic_watchdog, QueryExecutionContext::getRowSet(), GPU, RelAlgExecutionUnit::groupby_exprs, INJECT_TIMER, interrupted_(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), Executor::CompilationResult::literal_values, LOG, Executor::CompilationResult::native_functions, num_rows, QueryExecutionContext::query_mem_desc_, RenderInfo::render_allocator_map_ptr, and RenderInfo::useCudaBuffers().

                              {
   auto timer = DEBUG_TIMER(__func__);
   INJECT_TIMER(executePlanWithGroupBy);
   CHECK(!results);
   if (col_buffers.empty()) {
     return 0;
   }
   CHECK_NE(ra_exe_unit.groupby_exprs.size(), size_t(0));
   // TODO(alex):
   // 1. Optimize size (make keys more compact).
   // 2. Resize on overflow.
   // 3. Optimize runtime.
   auto hoist_buf = serializeLiterals(compilation_result.literal_values, device_id);
   int32_t error_code = device_type == ExecutorDeviceType::GPU ? 0 : start_rowid;
   const auto join_hash_table_ptrs = getJoinHashTablePtrs(device_type, device_id);
   if (g_enable_dynamic_watchdog && interrupted_) {
     return ERR_INTERRUPTED;
   }
 
   RenderAllocatorMap* render_allocator_map_ptr = nullptr;
   if (render_info && render_info->useCudaBuffers()) {
     render_allocator_map_ptr = render_info->render_allocator_map_ptr.get();
   }
 
   if (device_type == ExecutorDeviceType::CPU) {
     query_exe_context->launchCpuCode(ra_exe_unit,
                                      compilation_result.native_functions,
                                      hoist_literals,
                                      hoist_buf,
                                      col_buffers,
                                      num_rows,
                                      frag_offsets,
                                      scan_limit,
                                      &error_code,
                                      num_tables,
                                      join_hash_table_ptrs);
   } else {
     try {
       query_exe_context->launchGpuCode(ra_exe_unit,
                                        compilation_result.native_functions,
                                        hoist_literals,
                                        hoist_buf,
                                        col_buffers,
                                        num_rows,
                                        frag_offsets,
                                        scan_limit,
                                        data_mgr,
                                        blockSize(),
                                        gridSize(),
                                        device_id,
                                        &error_code,
                                        num_tables,
                                        join_hash_table_ptrs,
                                        render_allocator_map_ptr);
     } catch (const OutOfMemory&) {
       return ERR_OUT_OF_GPU_MEM;
     } catch (const OutOfRenderMemory&) {
       return ERR_OUT_OF_RENDER_MEM;
     } catch (const StreamingTopNNotSupportedInRenderQuery&) {
       return ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY;
     } catch (const std::bad_alloc&) {
       return ERR_SPECULATIVE_TOP_OOM;
     } catch (const std::exception& e) {
       LOG(FATAL) << "Error launching the GPU kernel: " << e.what();
     }
   }
 
   if (error_code == Executor::ERR_OVERFLOW_OR_UNDERFLOW ||
       error_code == Executor::ERR_DIV_BY_ZERO ||
       error_code == Executor::ERR_OUT_OF_TIME ||
       error_code == Executor::ERR_INTERRUPTED) {
     return error_code;
   }
 
   if (error_code != Executor::ERR_OVERFLOW_OR_UNDERFLOW &&
       error_code != Executor::ERR_DIV_BY_ZERO && !render_allocator_map_ptr) {
     results =
         query_exe_context->getRowSet(ra_exe_unit, query_exe_context->query_mem_desc_);
     CHECK(results);
     results->holdLiterals(hoist_buf);
   }
   if (error_code < 0 && render_allocator_map_ptr) {
     // More rows passed the filter than available slots. We don't have a count to check,
     // so assume we met the limit if a scan limit is set
     if (scan_limit != 0) {
       return 0;
     } else {
       return error_code;
     }
   }
   if (error_code && (!scan_limit || check_rows_less_than_needed(results, scan_limit))) {
     return error_code;  // unlucky, not enough results and we ran out of slots
   }
 
   return 0;
 }

Here is the call graph for this function:

int32_t Executor::executePlanWithoutGroupBy	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const CompilationResult &	compilation_result,
		const bool	hoist_literals,
		ResultSetPtr &	results,
		const std::vector< Analyzer::Expr * > &	target_exprs,
		const ExecutorDeviceType	device_type,
		std::vector< std::vector< const int8_t * >> &	col_buffers,
		QueryExecutionContext *	query_exe_context,
		const std::vector< std::vector< int64_t >> &	num_rows,
		const std::vector< std::vector< uint64_t >> &	frag_offsets,
		Data_Namespace::DataMgr *	data_mgr,
		const int	device_id,
		const uint32_t	start_rowid,
		const uint32_t	num_tables,
		RenderInfo *	render_info
	)

private

Definition at line 2259 of file Execute.cpp.

References CHECK(), CHECK_EQ, CPU, DEBUG_TIMER, ERR_DIV_BY_ZERO, ERR_INTERRUPTED, ERR_OUT_OF_TIME, ERR_OVERFLOW_OR_UNDERFLOW, error_code, RelAlgExecutionUnit::estimator, QueryExecutionContext::estimator_result_set_, logger::FATAL, g_bigint_count, g_enable_dynamic_watchdog, get_target_info(), Experimental::MetaTypeClassFactory< CLASSIFICATIONS_PACK >::getMetaTypeClass(), GPU, INJECT_TIMER, interrupted_(), RenderInfo::isPotentialInSituRender(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), Executor::CompilationResult::literal_values, LOG, Executor::CompilationResult::native_functions, num_rows, out, QueryExecutionContext::query_buffers_, RenderInfo::render_allocator_map_ptr, and RenderInfo::useCudaBuffers().

                              {
   INJECT_TIMER(executePlanWithoutGroupBy);
   auto timer = DEBUG_TIMER(__func__);
   CHECK(!results);
   if (col_buffers.empty()) {
     return 0;
   }
 
   RenderAllocatorMap* render_allocator_map_ptr = nullptr;
   if (render_info) {
     // TODO(adb): make sure that we either never get here in the CPU case, or if we do get
     // here, we are in non-insitu mode.
     CHECK(render_info->useCudaBuffers() || !render_info->isPotentialInSituRender())
         << "CUDA disabled rendering in the executePlanWithoutGroupBy query path is "
            "currently unsupported.";
     render_allocator_map_ptr = render_info->render_allocator_map_ptr.get();
   }
 
   int32_t error_code = device_type == ExecutorDeviceType::GPU ? 0 : start_rowid;
   std::vector<int64_t*> out_vec;
   const auto hoist_buf = serializeLiterals(compilation_result.literal_values, device_id);
   const auto join_hash_table_ptrs = getJoinHashTablePtrs(device_type, device_id);
   std::unique_ptr<OutVecOwner> output_memory_scope;
   if (g_enable_dynamic_watchdog && interrupted_) {
     return ERR_INTERRUPTED;
   }
   if (device_type == ExecutorDeviceType::CPU) {
     out_vec = query_exe_context->launchCpuCode(ra_exe_unit,
                                                compilation_result.native_functions,
                                                hoist_literals,
                                                hoist_buf,
                                                col_buffers,
                                                num_rows,
                                                frag_offsets,
                                                0,
                                                &error_code,
                                                num_tables,
                                                join_hash_table_ptrs);
     output_memory_scope.reset(new OutVecOwner(out_vec));
   } else {
     try {
       out_vec = query_exe_context->launchGpuCode(ra_exe_unit,
                                                  compilation_result.native_functions,
                                                  hoist_literals,
                                                  hoist_buf,
                                                  col_buffers,
                                                  num_rows,
                                                  frag_offsets,
                                                  0,
                                                  data_mgr,
                                                  blockSize(),
                                                  gridSize(),
                                                  device_id,
                                                  &error_code,
                                                  num_tables,
                                                  join_hash_table_ptrs,
                                                  render_allocator_map_ptr);
       output_memory_scope.reset(new OutVecOwner(out_vec));
     } catch (const OutOfMemory&) {
       return ERR_OUT_OF_GPU_MEM;
     } catch (const std::exception& e) {
       LOG(FATAL) << "Error launching the GPU kernel: " << e.what();
     }
   }
   if (error_code == Executor::ERR_OVERFLOW_OR_UNDERFLOW ||
       error_code == Executor::ERR_DIV_BY_ZERO ||
       error_code == Executor::ERR_OUT_OF_TIME ||
       error_code == Executor::ERR_INTERRUPTED) {
     return error_code;
   }
   if (ra_exe_unit.estimator) {
     CHECK(!error_code);
     results =
         std::shared_ptr<ResultSet>(query_exe_context->estimator_result_set_.release());
     return 0;
   }
   std::vector<int64_t> reduced_outs;
   const auto num_frags = col_buffers.size();
   const size_t entry_count = device_type == ExecutorDeviceType::GPU
                                  ? num_frags * blockSize() * gridSize()
                                  : num_frags;
   if (size_t(1) == entry_count) {
     for (auto out : out_vec) {
       CHECK(out);
       reduced_outs.push_back(*out);
     }
   } else {
     size_t out_vec_idx = 0;
 
     for (const auto target_expr : target_exprs) {
       const auto agg_info = get_target_info(target_expr, g_bigint_count);
       CHECK(agg_info.is_agg);
 
       auto meta_class(
           Experimental::GeoMetaTypeClassFactory::getMetaTypeClass(agg_info.sql_type));
       auto agg_reduction_impl =
           Experimental::GeoVsNonGeoClassHandler<AggregateReductionEgress>();
       agg_reduction_impl(meta_class,
                          entry_count,
                          error_code,
                          agg_info,
                          out_vec_idx,
                          out_vec,
                          reduced_outs,
                          query_exe_context);
       if (error_code) {
         break;
       }
     }
   }
 
   CHECK_EQ(size_t(1), query_exe_context->query_buffers_->result_sets_.size());
   auto rows_ptr = std::shared_ptr<ResultSet>(
       query_exe_context->query_buffers_->result_sets_[0].release());
   rows_ptr->fillOneEntry(reduced_outs);
   results = std::move(rows_ptr);
   return error_code;
 }

Here is the call graph for this function:

void Executor::executeSimpleInsert ( const Planner::RootPlan * root_plan )

private

Definition at line 2582 of file Execute.cpp.

References Importer_NS::appendDatum(), DataBlockPtr::arraysPtr, CHECK(), CHECK_EQ, checked_malloc(), Fragmenter_Namespace::InsertData::columnIds, Fragmenter_Namespace::InsertData::data, Fragmenter_Namespace::InsertData::databaseId, get_column_descriptor(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_compression(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_elem_type(), Planner::RootPlan::get_plan(), Planner::RootPlan::get_result_col_list(), Planner::RootPlan::get_result_table_id(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_size(), Planner::RootPlan::getCatalog(), Catalog_Namespace::Catalog::getMetadataForTable(), inline_fixed_encoding_null_val(), anonymous_namespace{Execute.cpp}::insert_one_dict_str(), anonymous_namespace{TypedDataAccessors.h}::is_null(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_string(), kARRAY, kBIGINT, kBOOLEAN, kCAST, kCHAR, kDATE, kDECIMAL, kDOUBLE, kENCODING_DICT, kENCODING_NONE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, DataBlockPtr::numbersPtr, Fragmenter_Namespace::InsertData::numRows, anonymous_namespace{TypedDataAccessors.h}::put_null(), anonymous_namespace{TypedDataAccessors.h}::put_null_array(), SHARD_FOR_KEY, DataBlockPtr::stringsPtr, Fragmenter_Namespace::InsertData::tableId, and to_string().

                                                                    {
   const auto plan = root_plan->get_plan();
   CHECK(plan);
   const auto values_plan = dynamic_cast<const Planner::ValuesScan*>(plan);
   if (!values_plan) {
     throw std::runtime_error(
         "Only simple INSERT of immediate tuples is currently supported");
   }
   row_set_mem_owner_ = std::make_shared<RowSetMemoryOwner>();
   const auto& targets = values_plan->get_targetlist();
   const int table_id = root_plan->get_result_table_id();
   const auto& col_id_list = root_plan->get_result_col_list();
   std::vector<const ColumnDescriptor*> col_descriptors;
   std::vector<int> col_ids;
   std::unordered_map<int, std::unique_ptr<uint8_t[]>> col_buffers;
   std::unordered_map<int, std::vector<std::string>> str_col_buffers;
   std::unordered_map<int, std::vector<ArrayDatum>> arr_col_buffers;
   auto& cat = root_plan->getCatalog();
   const auto table_descriptor = cat.getMetadataForTable(table_id);
   const auto shard_tables = cat.getPhysicalTablesDescriptors(table_descriptor);
   const TableDescriptor* shard{nullptr};
   for (const int col_id : col_id_list) {
     const auto cd = get_column_descriptor(col_id, table_id, cat);
     const auto col_enc = cd->columnType.get_compression();
     if (cd->columnType.is_string()) {
       switch (col_enc) {
         case kENCODING_NONE: {
           auto it_ok =
               str_col_buffers.insert(std::make_pair(col_id, std::vector<std::string>{}));
           CHECK(it_ok.second);
           break;
         }
         case kENCODING_DICT: {
           const auto dd = cat.getMetadataForDict(cd->columnType.get_comp_param());
           CHECK(dd);
           const auto it_ok = col_buffers.emplace(
               col_id, std::unique_ptr<uint8_t[]>(new uint8_t[cd->columnType.get_size()]));
           CHECK(it_ok.second);
           break;
         }
         default:
           CHECK(false);
       }
     } else if (cd->columnType.is_geometry()) {
       auto it_ok =
           str_col_buffers.insert(std::make_pair(col_id, std::vector<std::string>{}));
       CHECK(it_ok.second);
     } else if (cd->columnType.is_array()) {
       auto it_ok =
           arr_col_buffers.insert(std::make_pair(col_id, std::vector<ArrayDatum>{}));
       CHECK(it_ok.second);
     } else {
       const auto it_ok = col_buffers.emplace(
           col_id,
           std::unique_ptr<uint8_t[]>(
               new uint8_t[cd->columnType.get_logical_size()]()));  // changed to zero-init
                                                                    // the buffer
       CHECK(it_ok.second);
     }
     col_descriptors.push_back(cd);
     col_ids.push_back(col_id);
   }
   size_t col_idx = 0;
   Fragmenter_Namespace::InsertData insert_data;
   insert_data.databaseId = cat.getCurrentDB().dbId;
   insert_data.tableId = table_id;
   int64_t int_col_val{0};
   for (auto target_entry : targets) {
     auto col_cv = dynamic_cast<const Analyzer::Constant*>(target_entry->get_expr());
     if (!col_cv) {
       auto col_cast = dynamic_cast<const Analyzer::UOper*>(target_entry->get_expr());
       CHECK(col_cast);
       CHECK_EQ(kCAST, col_cast->get_optype());
       col_cv = dynamic_cast<const Analyzer::Constant*>(col_cast->get_operand());
     }
     CHECK(col_cv);
     const auto cd = col_descriptors[col_idx];
     auto col_datum = col_cv->get_constval();
     auto col_type = cd->columnType.get_type();
     uint8_t* col_data_bytes{nullptr};
     if (!cd->columnType.is_array() && !cd->columnType.is_geometry() &&
         (!cd->columnType.is_string() ||
          cd->columnType.get_compression() == kENCODING_DICT)) {
       const auto col_data_bytes_it = col_buffers.find(col_ids[col_idx]);
       CHECK(col_data_bytes_it != col_buffers.end());
       col_data_bytes = col_data_bytes_it->second.get();
     }
     switch (col_type) {
       case kBOOLEAN: {
         auto col_data = col_data_bytes;
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : (col_datum.boolval ? 1 : 0);
         break;
       }
       case kTINYINT: {
         auto col_data = reinterpret_cast<int8_t*>(col_data_bytes);
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : col_datum.tinyintval;
         int_col_val = col_datum.tinyintval;
         break;
       }
       case kSMALLINT: {
         auto col_data = reinterpret_cast<int16_t*>(col_data_bytes);
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : col_datum.smallintval;
         int_col_val = col_datum.smallintval;
         break;
       }
       case kINT: {
         auto col_data = reinterpret_cast<int32_t*>(col_data_bytes);
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : col_datum.intval;
         int_col_val = col_datum.intval;
         break;
       }
       case kBIGINT:
       case kDECIMAL:
       case kNUMERIC: {
         auto col_data = reinterpret_cast<int64_t*>(col_data_bytes);
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : col_datum.bigintval;
         int_col_val = col_datum.bigintval;
         break;
       }
       case kFLOAT: {
         auto col_data = reinterpret_cast<float*>(col_data_bytes);
         *col_data = col_datum.floatval;
         break;
       }
       case kDOUBLE: {
         auto col_data = reinterpret_cast<double*>(col_data_bytes);
         *col_data = col_datum.doubleval;
         break;
       }
       case kTEXT:
       case kVARCHAR:
       case kCHAR: {
         switch (cd->columnType.get_compression()) {
           case kENCODING_NONE:
             str_col_buffers[col_ids[col_idx]].push_back(
                 col_datum.stringval ? *col_datum.stringval : "");
             break;
           case kENCODING_DICT: {
             switch (cd->columnType.get_size()) {
               case 1:
                 int_col_val = insert_one_dict_str(
                     reinterpret_cast<uint8_t*>(col_data_bytes), cd, col_cv, cat);
                 break;
               case 2:
                 int_col_val = insert_one_dict_str(
                     reinterpret_cast<uint16_t*>(col_data_bytes), cd, col_cv, cat);
                 break;
               case 4:
                 int_col_val = insert_one_dict_str(
                     reinterpret_cast<int32_t*>(col_data_bytes), cd, col_cv, cat);
                 break;
               default:
                 CHECK(false);
             }
             break;
           }
           default:
             CHECK(false);
         }
         break;
       }
       case kTIME:
       case kTIMESTAMP:
       case kDATE: {
         auto col_data = reinterpret_cast<int64_t*>(col_data_bytes);
         *col_data = col_cv->get_is_null() ? inline_fixed_encoding_null_val(cd->columnType)
                                           : col_datum.bigintval;
         break;
       }
       case kARRAY: {
         const auto is_null = col_cv->get_is_null();
         const auto size = cd->columnType.get_size();
         const SQLTypeInfo elem_ti = cd->columnType.get_elem_type();
         if (is_null) {
           if (size > 0) {
             // NULL fixlen array: NULL_ARRAY sentinel followed by NULL sentinels
             if (elem_ti.is_string() && elem_ti.get_compression() == kENCODING_DICT) {
               throw std::runtime_error("Column " + cd->columnName +
                                        " doesn't accept NULL values");
             }
             int8_t* buf = (int8_t*)checked_malloc(size);
             put_null_array(static_cast<void*>(buf), elem_ti, "");
             for (int8_t* p = buf + elem_ti.get_size(); (p - buf) < size;
                  p += elem_ti.get_size()) {
               put_null(static_cast<void*>(p), elem_ti, "");
             }
             arr_col_buffers[col_ids[col_idx]].emplace_back(size, buf, is_null);
           } else {
             arr_col_buffers[col_ids[col_idx]].emplace_back(0, nullptr, is_null);
           }
           break;
         }
         const auto l = col_cv->get_value_list();
         size_t len = l.size() * elem_ti.get_size();
         if (size > 0 && static_cast<size_t>(size) != len) {
           throw std::runtime_error("Array column " + cd->columnName + " expects " +
                                    std::to_string(size / elem_ti.get_size()) +
                                    " values, " + "received " + std::to_string(l.size()));
         }
         if (elem_ti.is_string()) {
           CHECK(kENCODING_DICT == elem_ti.get_compression());
           CHECK(4 == elem_ti.get_size());
 
           int8_t* buf = (int8_t*)checked_malloc(len);
           int32_t* p = reinterpret_cast<int32_t*>(buf);
 
           int elemIndex = 0;
           for (auto& e : l) {
             auto c = std::dynamic_pointer_cast<Analyzer::Constant>(e);
             CHECK(c);
 
             int_col_val =
                 insert_one_dict_str(&p[elemIndex], cd->columnName, elem_ti, c.get(), cat);
 
             elemIndex++;
           }
           arr_col_buffers[col_ids[col_idx]].push_back(ArrayDatum(len, buf, is_null));
 
         } else {
           int8_t* buf = (int8_t*)checked_malloc(len);
           int8_t* p = buf;
           for (auto& e : l) {
             auto c = std::dynamic_pointer_cast<Analyzer::Constant>(e);
             CHECK(c);
             p = Importer_NS::appendDatum(p, c->get_constval(), elem_ti);
           }
           arr_col_buffers[col_ids[col_idx]].push_back(ArrayDatum(len, buf, is_null));
         }
         break;
       }
       case kPOINT:
       case kLINESTRING:
       case kPOLYGON:
       case kMULTIPOLYGON:
         str_col_buffers[col_ids[col_idx]].push_back(
             col_datum.stringval ? *col_datum.stringval : "");
         break;
       default:
         CHECK(false);
     }
     ++col_idx;
     if (col_idx == static_cast<size_t>(table_descriptor->shardedColumnId)) {
       const auto shard_count = shard_tables.size();
       const size_t shard_idx = SHARD_FOR_KEY(int_col_val, shard_count);
       shard = shard_tables[shard_idx];
     }
   }
   for (const auto& kv : col_buffers) {
     insert_data.columnIds.push_back(kv.first);
     DataBlockPtr p;
     p.numbersPtr = reinterpret_cast<int8_t*>(kv.second.get());
     insert_data.data.push_back(p);
   }
   for (auto& kv : str_col_buffers) {
     insert_data.columnIds.push_back(kv.first);
     DataBlockPtr p;
     p.stringsPtr = &kv.second;
     insert_data.data.push_back(p);
   }
   for (auto& kv : arr_col_buffers) {
     insert_data.columnIds.push_back(kv.first);
     DataBlockPtr p;
     p.arraysPtr = &kv.second;
     insert_data.data.push_back(p);
   }
   insert_data.numRows = 1;
   if (shard) {
     shard->fragmenter->insertData(insert_data);
   } else {
     table_descriptor->fragmenter->insertData(insert_data);
   }
 }

Here is the call graph for this function:

ResultSetPtr Executor::executeTableFunction	(	const TableFunctionExecutionUnit	exe_unit,
		const std::vector< InputTableInfo > &	table_infos,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo,
		const Catalog_Namespace::Catalog &	cat
	)

private

Compiles and dispatches a table function; that is, a function that takes as input one or more columns and returns a ResultSet, which can be parsed by subsequent execution steps.

Definition at line 1346 of file Execute.cpp.

References CHECK_EQ, TableFunctionCompilationContext::compile(), CompilationOptions::device_type_, TableFunctionExecutionContext::execute(), and INJECT_TIMER.

                                          {
   INJECT_TIMER(Exec_executeTableFunction);
   nukeOldState(false, table_infos, nullptr);
 
   ColumnCacheMap column_cache;  // Note: if we add retries to the table function
                                 // framework, we may want to move this up a level
 
   ColumnFetcher column_fetcher(this, column_cache);
   TableFunctionCompilationContext compilation_context;
   compilation_context.compile(exe_unit, co, this);
 
   TableFunctionExecutionContext exe_context(getRowSetMemoryOwner());
   CHECK_EQ(table_infos.size(), size_t(1));
   return exe_context.execute(exe_unit,
                              table_infos.front(),
                              &compilation_context,
                              column_fetcher,
                              co.device_type_,
                              this);
 }

Here is the call graph for this function:

void Executor::executeUpdate	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	table_infos,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo,
		const Catalog_Namespace::Catalog &	cat,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const UpdateLogForFragment::Callback &	cb,
		const bool	is_agg = `false`
	)

private

Definition at line 60 of file ExecuteUpdate.cpp.

References CHECK(), CHECK_EQ, CHECK_GT, Executor::ExecutionDispatch::compile(), create_count_all_execution_unit(), CompilationOptions::device_type_, FragmentsPerTable::fragment_ids, g_bigint_count, Executor::ExecutionDispatch::getFragmentResults(), kBIGINT, kCOUNT, KernelPerFragment, kINT, and Executor::ExecutionDispatch::run().

                                                 {
   CHECK(cb);
   const auto ra_exe_unit = addDeletedColumn(ra_exe_unit_in);
   ColumnCacheMap column_cache;
 
   const auto count =
       makeExpr<Analyzer::AggExpr>(SQLTypeInfo(g_bigint_count ? kBIGINT : kINT, false),
                                   kCOUNT,
                                   nullptr,
                                   false,
                                   nullptr);
   const auto count_all_exe_unit = create_count_all_execution_unit(ra_exe_unit, count);
 
   ColumnFetcher column_fetcher(this, column_cache);
   CHECK_GT(ra_exe_unit.input_descs.size(), size_t(0));
   const auto table_id = ra_exe_unit.input_descs[0].getTableId();
   const auto& outer_fragments = table_infos.front().info.fragments;
 
   std::vector<FragmentsPerTable> fragments = {{0, {0}}};
   for (size_t tab_idx = 1; tab_idx < ra_exe_unit.input_descs.size(); tab_idx++) {
     int table_id = ra_exe_unit.input_descs[tab_idx].getTableId();
     CHECK_EQ(table_infos[tab_idx].table_id, table_id);
     const auto& fragmentsPerTable = table_infos[tab_idx].info.fragments;
     FragmentsPerTable entry = {table_id, {}};
     for (size_t innerFragId = 0; innerFragId < fragmentsPerTable.size(); innerFragId++) {
       entry.fragment_ids.push_back(innerFragId);
     }
     fragments.push_back(entry);
   }
 
   // There could be benefit to multithread this once we see where the bottle necks really
   // are
   for (size_t fragment_index = 0; fragment_index < outer_fragments.size();
        ++fragment_index) {
     ExecutionDispatch current_fragment_execution_dispatch(
         this, ra_exe_unit, table_infos, cat, row_set_mem_owner, nullptr);
 
     const int64_t crt_fragment_tuple_count =
         outer_fragments[fragment_index].getNumTuples();
     int64_t max_groups_buffer_entry_guess = crt_fragment_tuple_count;
     if (is_agg) {
       max_groups_buffer_entry_guess =
           std::min(2 * max_groups_buffer_entry_guess, static_cast<int64_t>(100'000'000));
     }
 
     const auto execution_descriptors = current_fragment_execution_dispatch.compile(
         max_groups_buffer_entry_guess, 8, co, eo, column_fetcher, true);
     // We may want to consider in the future allowing this to execute on devices other
     // than CPU
 
     fragments[0] = {table_id, {fragment_index}};
 
     current_fragment_execution_dispatch.run(
         co.device_type_,
         0,
         eo,
         column_fetcher,
         *std::get<QueryCompilationDescriptorOwned>(execution_descriptors),
         *std::get<QueryMemoryDescriptorOwned>(execution_descriptors),
         fragments,
         ExecutorDispatchMode::KernelPerFragment,
         -1);
     const auto& proj_fragment_results =
         current_fragment_execution_dispatch.getFragmentResults();
     if (proj_fragment_results.empty()) {
       continue;
     }
     const auto& proj_fragment_result = proj_fragment_results[0];
     const auto proj_result_set = proj_fragment_result.first;
     CHECK(proj_result_set);
     cb({outer_fragments[fragment_index], fragment_index, proj_result_set});
   }
 }

Here is the call graph for this function:

ResultSetPtr Executor::executeWorkUnit	(	size_t &	max_groups_buffer_entry_guess,
		const bool	is_agg,
		const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit_in,
		const CompilationOptions &	co,
		const ExecutionOptions &	options,
		const Catalog_Namespace::Catalog &	cat,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		RenderInfo *	render_info,
		const bool	has_cardinality_estimation,
		ColumnCacheMap &	column_cache
	)

private

Definition at line 1109 of file Execute.cpp.

References CompilationRetryNewScanLimit::new_scan_limit_, and anonymous_namespace{Execute.cpp}::replace_scan_limit().

                                   {
   try {
     return executeWorkUnitImpl(max_groups_buffer_entry_guess,
                                is_agg,
                                true,
                                query_infos,
                                ra_exe_unit_in,
                                co,
                                eo,
                                cat,
                                row_set_mem_owner,
                                render_info,
                                has_cardinality_estimation,
                                column_cache);
   } catch (const CompilationRetryNewScanLimit& e) {
     return executeWorkUnitImpl(max_groups_buffer_entry_guess,
                                is_agg,
                                false,
                                query_infos,
                                replace_scan_limit(ra_exe_unit_in, e.new_scan_limit_),
                                co,
                                eo,
                                cat,
                                row_set_mem_owner,
                                render_info,
                                has_cardinality_estimation,
                                column_cache);
   }
 }

Here is the call graph for this function:

ResultSetPtr Executor::executeWorkUnitImpl	(	size_t &	max_groups_buffer_entry_guess,
		const bool	is_agg,
		const bool	allow_single_frag_table_opt,
		const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit_in,
		const CompilationOptions &	co,
		const ExecutionOptions &	options,
		const Catalog_Namespace::Catalog &	cat,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		RenderInfo *	render_info,
		const bool	has_cardinality_estimation,
		ColumnCacheMap &	column_cache
	)

private

Definition at line 1150 of file Execute.cpp.

References CHECK(), Executor::ExecutionDispatch::compile(), anonymous_namespace{Execute.cpp}::compute_buffer_entry_guess(), CPU, cpu_threads(), DEBUG_TIMER_NEW_THREAD, CompilationOptions::device_type_, CompilationOptions::explain_type_, Data_Namespace::DataMgr::freeAllBuffers(), get_available_gpus(), get_context_count(), get_min_byte_width(), Catalog_Namespace::Catalog::getDataMgr(), QueryExecutionError::getErrorCode(), Data_Namespace::DataMgr::getMemoryInfo(), GPU, Data_Namespace::GPU_LEVEL, CompilationOptions::hoist_literals_, INJECT_TIMER, interrupted_(), ExecutionOptions::just_explain, MAX_BYTE_WIDTH_SUPPORTED, CompilationOptions::opt_level_, query_mem_desc, CompilationOptions::register_intel_jit_listener_, Executor::ExecutionDispatch::run(), and CompilationOptions::with_dynamic_watchdog_.

                                   {
   INJECT_TIMER(Exec_executeWorkUnit);
   const auto ra_exe_unit = addDeletedColumn(ra_exe_unit_in);
   const auto device_type = getDeviceTypeForTargets(ra_exe_unit, co.device_type_);
   CHECK(!query_infos.empty());
   if (!max_groups_buffer_entry_guess) {
     // The query has failed the first execution attempt because of running out
     // of group by slots. Make the conservative choice: allocate fragment size
     // slots and run on the CPU.
     CHECK(device_type == ExecutorDeviceType::CPU);
     max_groups_buffer_entry_guess = compute_buffer_entry_guess(query_infos);
   }
 
   int8_t crt_min_byte_width{get_min_byte_width()};
   do {
     ExecutionDispatch execution_dispatch(
         this, ra_exe_unit, query_infos, cat, row_set_mem_owner, render_info);
     ColumnFetcher column_fetcher(this, column_cache);
     std::unique_ptr<QueryCompilationDescriptor> query_comp_desc_owned;
     std::unique_ptr<QueryMemoryDescriptor> query_mem_desc_owned;
     try {
       INJECT_TIMER(execution_dispatch_comp);
       std::tie(query_comp_desc_owned, query_mem_desc_owned) =
           execution_dispatch.compile(max_groups_buffer_entry_guess,
                                      crt_min_byte_width,
                                      {device_type,
                                       co.hoist_literals_,
                                       co.opt_level_,
                                       co.with_dynamic_watchdog_,
                                       co.explain_type_,
                                       co.register_intel_jit_listener_},
                                      eo,
                                      column_fetcher,
                                      has_cardinality_estimation);
       CHECK(query_comp_desc_owned);
       crt_min_byte_width = query_comp_desc_owned->getMinByteWidth();
     } catch (CompilationRetryNoCompaction&) {
       crt_min_byte_width = MAX_BYTE_WIDTH_SUPPORTED;
       continue;
     }
     if (eo.just_explain) {
       return executeExplain(*query_comp_desc_owned);
     }
 
     for (const auto target_expr : ra_exe_unit.target_exprs) {
       plan_state_->target_exprs_.push_back(target_expr);
     }
 
     auto dispatch = [&execution_dispatch,
                      &column_fetcher,
                      &eo,
                      parent_thread_id = std::this_thread::get_id()](
                         const ExecutorDeviceType chosen_device_type,
                         int chosen_device_id,
                         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) {
       DEBUG_TIMER_NEW_THREAD(parent_thread_id);
       INJECT_TIMER(execution_dispatch_run);
       execution_dispatch.run(chosen_device_type,
                              chosen_device_id,
                              eo,
                              column_fetcher,
                              query_comp_desc,
                              query_mem_desc,
                              frag_list,
                              kernel_dispatch_mode,
                              rowid_lookup_key);
     };
 
     QueryFragmentDescriptor fragment_descriptor(
         ra_exe_unit,
         query_infos,
         query_comp_desc_owned->getDeviceType() == ExecutorDeviceType::GPU
             ? cat.getDataMgr().getMemoryInfo(Data_Namespace::MemoryLevel::GPU_LEVEL)
             : std::vector<Data_Namespace::MemoryInfo>{},
         eo.gpu_input_mem_limit_percent);
 
     if (!eo.just_validate) {
       int available_cpus = cpu_threads();
       auto available_gpus = get_available_gpus(cat);
 
       const auto context_count =
           get_context_count(device_type, available_cpus, available_gpus.size());
       try {
         dispatchFragments(dispatch,
                           execution_dispatch,
                           query_infos,
                           eo,
                           is_agg,
                           allow_single_frag_table_opt,
                           context_count,
                           *query_comp_desc_owned,
                           *query_mem_desc_owned,
                           fragment_descriptor,
                           available_gpus,
                           available_cpus);
       } catch (QueryExecutionError& e) {
         if (eo.with_dynamic_watchdog && interrupted_ &&
             e.getErrorCode() == ERR_OUT_OF_TIME) {
           throw QueryExecutionError(ERR_INTERRUPTED);
         }
         cat.getDataMgr().freeAllBuffers();
         if (e.getErrorCode() == ERR_OVERFLOW_OR_UNDERFLOW &&
             static_cast<size_t>(crt_min_byte_width << 1) <= sizeof(int64_t)) {
           crt_min_byte_width <<= 1;
           continue;
         }
         throw;
       }
     }
     cat.getDataMgr().freeAllBuffers();
     if (is_agg) {
       try {
         return collectAllDeviceResults(execution_dispatch,
                                        ra_exe_unit.target_exprs,
                                        *query_mem_desc_owned,
                                        query_comp_desc_owned->getDeviceType(),
                                        row_set_mem_owner);
       } catch (ReductionRanOutOfSlots&) {
         throw QueryExecutionError(ERR_OUT_OF_SLOTS);
       } catch (OverflowOrUnderflow&) {
         crt_min_byte_width <<= 1;
         continue;
       }
     }
     return resultsUnion(execution_dispatch);
 
   } while (static_cast<size_t>(crt_min_byte_width) <= sizeof(int64_t));
 
   return std::make_shared<ResultSet>(std::vector<TargetInfo>{},
                                      ExecutorDeviceType::CPU,
                                      QueryMemoryDescriptor(),
                                      nullptr,
                                      this);
 }

Here is the call graph for this function:

void Executor::executeWorkUnitPerFragment	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const InputTableInfo &	table_info,
		const CompilationOptions &	co,
		const ExecutionOptions &	eo,
		const Catalog_Namespace::Catalog &	cat,
		PerFragmentCallBack &	cb
	)

private

Compiles and dispatches a work unit per fragment processing results with the per fragment callback. Currently used for computing metrics over fragments (metadata).

Definition at line 1301 of file Execute.cpp.

References CHECK_EQ, Executor::ExecutionDispatch::compile(), CompilationOptions::device_type_, Fragmenter_Namespace::TableInfo::fragments, InputTableInfo::info, and Executor::ExecutionDispatch::run().

                                                                    {
   const auto ra_exe_unit = addDeletedColumn(ra_exe_unit_in);
   ColumnCacheMap column_cache;
 
   std::vector<InputTableInfo> table_infos{table_info};
   // TODO(adb): ensure this is under a try / catch
   ExecutionDispatch execution_dispatch(
       this, ra_exe_unit, table_infos, cat, row_set_mem_owner_, nullptr);
   ColumnFetcher column_fetcher(this, column_cache);
   std::unique_ptr<QueryCompilationDescriptor> query_comp_desc_owned;
   std::unique_ptr<QueryMemoryDescriptor> query_mem_desc_owned;
   std::tie(query_comp_desc_owned, query_mem_desc_owned) =
       execution_dispatch.compile(0, 8, co, eo, column_fetcher, false);
   CHECK_EQ(size_t(1), ra_exe_unit.input_descs.size());
   const auto table_id = ra_exe_unit.input_descs[0].getTableId();
   const auto& outer_fragments = table_info.info.fragments;
   for (size_t fragment_index = 0; fragment_index < outer_fragments.size();
        ++fragment_index) {
     // We may want to consider in the future allowing this to execute on devices other
     // than CPU
     execution_dispatch.run(co.device_type_,
                            0,
                            eo,
                            column_fetcher,
                            *query_comp_desc_owned,
                            *query_mem_desc_owned,
                            {{table_id, {fragment_index}}},
                            ExecutorDispatchMode::KernelPerFragment,
                            -1);
   }
 
   const auto& all_fragment_results = execution_dispatch.getFragmentResults();
 
   for (size_t fragment_index = 0; fragment_index < outer_fragments.size();
        ++fragment_index) {
     const auto fragment_results = all_fragment_results[fragment_index];
     cb(fragment_results.first, outer_fragments[fragment_index]);
   }
 }

Here is the call graph for this function:

Executor::FetchResult Executor::fetchChunks	(	const ColumnFetcher &	column_fetcher,
		const RelAlgExecutionUnit &	ra_exe_unit,
		const int	device_id,
		const Data_Namespace::MemoryLevel	memory_level,
		const std::map< int, const TableFragments * > &	all_tables_fragments,
		const FragmentsList &	selected_fragments,
		const Catalog_Namespace::Catalog &	cat,
		std::list< ChunkIter > &	chunk_iterators,
		std::list< std::shared_ptr< Chunk_NS::Chunk >> &	chunks
	)

private

Definition at line 2014 of file Execute.cpp.

References CHECK(), CHECK_EQ, CHECK_LT, Data_Namespace::CPU_LEVEL, DEBUG_TIMER, ColumnFetcher::getAllTableColumnFragments(), ColumnFetcher::getOneTableColumnFragment(), ColumnFetcher::getResultSetColumn(), INJECT_TIMER, RelAlgExecutionUnit::input_col_descs, RelAlgExecutionUnit::input_descs, RESULT, and anonymous_namespace{Execute.cpp}::try_get_column_descriptor().

                                                    {
   auto timer = DEBUG_TIMER(__func__);
   INJECT_TIMER(fetchChunks);
   const auto& col_global_ids = ra_exe_unit.input_col_descs;
   std::vector<std::vector<size_t>> selected_fragments_crossjoin;
   std::vector<size_t> local_col_to_frag_pos;
   buildSelectedFragsMapping(selected_fragments_crossjoin,
                             local_col_to_frag_pos,
                             col_global_ids,
                             selected_fragments,
                             ra_exe_unit);
 
   CartesianProduct<std::vector<std::vector<size_t>>> frag_ids_crossjoin(
       selected_fragments_crossjoin);
 
   std::vector<std::vector<const int8_t*>> all_frag_col_buffers;
   std::vector<std::vector<int64_t>> all_num_rows;
   std::vector<std::vector<uint64_t>> all_frag_offsets;
 
   for (const auto& selected_frag_ids : frag_ids_crossjoin) {
     std::vector<const int8_t*> frag_col_buffers(
         plan_state_->global_to_local_col_ids_.size());
     for (const auto& col_id : col_global_ids) {
       CHECK(col_id);
       const int table_id = col_id->getScanDesc().getTableId();
       const auto cd = try_get_column_descriptor(col_id.get(), cat);
       if (cd && cd->isVirtualCol) {
         CHECK_EQ("rowid", cd->columnName);
         continue;
       }
       const auto fragments_it = all_tables_fragments.find(table_id);
       CHECK(fragments_it != all_tables_fragments.end());
       const auto fragments = fragments_it->second;
       auto it = plan_state_->global_to_local_col_ids_.find(*col_id);
       CHECK(it != plan_state_->global_to_local_col_ids_.end());
       CHECK_LT(static_cast<size_t>(it->second),
                plan_state_->global_to_local_col_ids_.size());
       const size_t frag_id = selected_frag_ids[local_col_to_frag_pos[it->second]];
       if (!fragments->size()) {
         return {};
       }
       CHECK_LT(frag_id, fragments->size());
       auto memory_level_for_column = memory_level;
       if (plan_state_->columns_to_fetch_.find(
               std::make_pair(col_id->getScanDesc().getTableId(), col_id->getColId())) ==
           plan_state_->columns_to_fetch_.end()) {
         memory_level_for_column = Data_Namespace::CPU_LEVEL;
       }
       if (col_id->getScanDesc().getSourceType() == InputSourceType::RESULT) {
         frag_col_buffers[it->second] = column_fetcher.getResultSetColumn(
             col_id.get(), memory_level_for_column, device_id);
       } else {
         if (needFetchAllFragments(*col_id, ra_exe_unit, selected_fragments)) {
           frag_col_buffers[it->second] =
               column_fetcher.getAllTableColumnFragments(table_id,
                                                         col_id->getColId(),
                                                         all_tables_fragments,
                                                         memory_level_for_column,
                                                         device_id);
         } else {
           frag_col_buffers[it->second] =
               column_fetcher.getOneTableColumnFragment(table_id,
                                                        frag_id,
                                                        col_id->getColId(),
                                                        all_tables_fragments,
                                                        chunks,
                                                        chunk_iterators,
                                                        memory_level_for_column,
                                                        device_id);
         }
       }
     }
     all_frag_col_buffers.push_back(frag_col_buffers);
   }
   std::tie(all_num_rows, all_frag_offsets) = getRowCountAndOffsetForAllFrags(
       ra_exe_unit, frag_ids_crossjoin, ra_exe_unit.input_descs, all_tables_fragments);
   return {all_frag_col_buffers, all_num_rows, all_frag_offsets};
 }

Here is the call graph for this function:

std::string Executor::generatePTX ( const std::string & cuda_llir ) const

private

Definition at line 899 of file NativeCodegen.cpp.

                                                                 {
   return CodeGenerator::generatePTX(
       cuda_llir, nvptx_target_machine_.get(), cgen_state_.get());
 }

const Catalog_Namespace::Catalog * Executor::getCatalog ( ) const

Definition at line 233 of file Execute.cpp.

References catalog_().

                                                            {
   return catalog_;
 }

Here is the call graph for this function:

std::vector< std::pair< void , void > > Executor::getCodeFromCache	(	const CodeCacheKey &	key,
		const CodeCache &	cache
	)

private

Definition at line 171 of file NativeCodegen.cpp.

References LruCache< key_t, value_t, hash_t >::cend(), LruCache< key_t, value_t, hash_t >::find(), and GpuCompilationContext::module().

                                                                                         {
   auto it = cache.find(key);
   if (it != cache.cend()) {
     delete cgen_state_->module_;
     cgen_state_->module_ = it->second.second;
     std::vector<std::pair<void*, void*>> native_functions;
     for (auto& native_code : it->second.first) {
       GpuCompilationContext* gpu_context = std::get<2>(native_code).get();
       native_functions.emplace_back(std::get<0>(native_code),
                                     gpu_context ? gpu_context->module() : nullptr);
     }
     return native_functions;
   }
   return {};
 }

Here is the call graph for this function:

std::vector< ColumnLazyFetchInfo > Executor::getColLazyFetchInfo ( const std::vector< Analyzer::Expr * > & target_exprs ) const

Definition at line 287 of file Execute.cpp.

References catalog_(), CHECK(), ColumnDescriptor::columnType, get_column_descriptor(), IS_GEO, and kNULLT.

                                                         {
   CHECK(plan_state_);
   CHECK(catalog_);
   std::vector<ColumnLazyFetchInfo> col_lazy_fetch_info;
   for (const auto target_expr : target_exprs) {
     if (!plan_state_->isLazyFetchColumn(target_expr)) {
       col_lazy_fetch_info.emplace_back(
           ColumnLazyFetchInfo{false, -1, SQLTypeInfo(kNULLT, false)});
     } else {
       const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(target_expr);
       CHECK(col_var);
       auto col_id = col_var->get_column_id();
       auto rte_idx = (col_var->get_rte_idx() == -1) ? 0 : col_var->get_rte_idx();
       auto cd = (col_var->get_table_id() > 0)
                     ? get_column_descriptor(col_id, col_var->get_table_id(), *catalog_)
                     : nullptr;
       if (cd && IS_GEO(cd->columnType.get_type())) {
         // Geo coords cols will be processed in sequence. So we only need to track the
         // first coords col in lazy fetch info.
         {
           auto cd0 =
               get_column_descriptor(col_id + 1, col_var->get_table_id(), *catalog_);
           auto col0_ti = cd0->columnType;
           CHECK(!cd0->isVirtualCol);
           auto col0_var = makeExpr<Analyzer::ColumnVar>(
               col0_ti, col_var->get_table_id(), cd0->columnId, rte_idx);
           auto local_col0_id = plan_state_->getLocalColumnId(col0_var.get(), false);
           col_lazy_fetch_info.emplace_back(
               ColumnLazyFetchInfo{true, local_col0_id, col0_ti});
         }
       } else {
         auto local_col_id = plan_state_->getLocalColumnId(col_var, false);
         const auto& col_ti = col_var->get_type_info();
         col_lazy_fetch_info.emplace_back(ColumnLazyFetchInfo{true, local_col_id, col_ti});
       }
     }
   }
   return col_lazy_fetch_info;
 }

Here is the call graph for this function:

ExpressionRange Executor::getColRange ( const PhysicalInput & phys_input ) const

Definition at line 257 of file Execute.cpp.

                                                                            {
   return agg_col_range_cache_.getColRange(phys_input);
 }

const ColumnDescriptor * Executor::getColumnDescriptor ( const Analyzer::ColumnVar * col_var ) const

Definition at line 216 of file Execute.cpp.

References catalog_(), get_column_descriptor_maybe(), Analyzer::ColumnVar::get_column_id(), and Analyzer::ColumnVar::get_table_id().

                                             {
   return get_column_descriptor_maybe(
       col_var->get_column_id(), col_var->get_table_id(), *catalog_);
 }

Here is the call graph for this function:

ExecutorDeviceType Executor::getDeviceTypeForTargets	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const ExecutorDeviceType	requested_device_type
	)

private

Definition at line 1378 of file Execute.cpp.

References CPU, g_bigint_count, get_target_info(), RelAlgExecutionUnit::groupby_exprs, kAVG, kDOUBLE, kSUM, and RelAlgExecutionUnit::target_exprs.

                                                     {
   for (const auto target_expr : ra_exe_unit.target_exprs) {
     const auto agg_info = get_target_info(target_expr, g_bigint_count);
     if (!ra_exe_unit.groupby_exprs.empty() &&
         !isArchPascalOrLater(requested_device_type)) {
       if ((agg_info.agg_kind == kAVG || agg_info.agg_kind == kSUM) &&
           agg_info.agg_arg_type.get_type() == kDOUBLE) {
         return ExecutorDeviceType::CPU;
       }
     }
     if (dynamic_cast<const Analyzer::RegexpExpr*>(target_expr)) {
       return ExecutorDeviceType::CPU;
     }
   }
   return requested_device_type;
 }

Here is the call graph for this function:

std::shared_ptr< Executor > Executor::getExecutor	(	const int	db_id,
		const std::string &	debug_dir = `""`,
		const std::string &	debug_file = `""`,
		const MapDParameters	mapd_parameters = `MapDParameters()`,
		::QueryRenderer::QueryRenderManager *	render_manager = `nullptr`
	)

static

Definition at line 127 of file Execute.cpp.

References CHECK(), MapDParameters::cuda_block_size, MapDParameters::cuda_grid_size, and INJECT_TIMER.

Referenced by Catalog_Namespace::Catalog::checkDateInDaysColumnMigration(), MapDHandler::execute_rel_alg(), MapDHandler::execute_rel_alg_df(), MapDHandler::execute_root_plan(), Parser::getResultSet(), MapDHandler::interrupt(), Parser::InsertIntoTableAsSelectStmt::populateData(), QueryRunner::anonymous_namespace{QueryRunner.cpp}::run_select_query_with_filter_push_down(), QueryRunner::QueryRunner::runSelectQuery(), QueryRunner::QueryRunner::runSQL(), MapDHandler::sql_execute_impl(), and Fragmenter_Namespace::InsertOrderFragmenter::updateColumns().

                                                      {
   INJECT_TIMER(getExecutor);
   const auto executor_key = std::make_pair(db_id, render_manager);
   {
     mapd_shared_lock<mapd_shared_mutex> read_lock(executors_cache_mutex_);
     auto it = executors_.find(executor_key);
     if (it != executors_.end()) {
       return it->second;
     }
   }
   {
     mapd_unique_lock<mapd_shared_mutex> write_lock(executors_cache_mutex_);
     auto it = executors_.find(executor_key);
     if (it != executors_.end()) {
       return it->second;
     }
     auto executor = std::make_shared<Executor>(db_id,
                                                mapd_parameters.cuda_block_size,
                                                mapd_parameters.cuda_grid_size,
                                                debug_dir,
                                                debug_file,
                                                render_manager);
     auto it_ok = executors_.insert(std::make_pair(executor_key, executor));
     CHECK(it_ok.second);
     return executor;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< size_t > Executor::getFragmentCount	(	const FragmentsList &	selected_fragments,
		const size_t	scan_idx,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

private

Definition at line 2102 of file Execute.cpp.

References RelAlgExecutionUnit::input_descs, and RelAlgExecutionUnit::join_quals.

                                                                                        {
   if ((ra_exe_unit.input_descs.size() > size_t(2) || !ra_exe_unit.join_quals.empty()) &&
       scan_idx > 0 &&
       !plan_state_->join_info_.sharded_range_table_indices_.count(scan_idx) &&
       !selected_fragments[scan_idx].fragment_ids.empty()) {
     // Fetch all fragments
     return {size_t(0)};
   }
 
   return selected_fragments[scan_idx].fragment_ids;
 }

std::unordered_map< int, const Analyzer::BinOper * > Executor::getInnerTabIdToJoinCond ( ) const

private

Definition at line 1666 of file Execute.cpp.

References CHECK_EQ.

           {
   std::unordered_map<int, const Analyzer::BinOper*> id_to_cond;
   const auto& join_info = plan_state_->join_info_;
   CHECK_EQ(join_info.equi_join_tautologies_.size(), join_info.join_hash_tables_.size());
   for (size_t i = 0; i < join_info.join_hash_tables_.size(); ++i) {
     int inner_table_id = join_info.join_hash_tables_[i]->getInnerTableId();
     id_to_cond.insert(
         std::make_pair(inner_table_id, join_info.equi_join_tautologies_[i].get()));
   }
   return id_to_cond;
 }

std::vector< int64_t > Executor::getJoinHashTablePtrs	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)

private

Definition at line 2515 of file Execute.cpp.

References CHECK(), GPU, and join_hash_tables.

                                                                          {
   std::vector<int64_t> table_ptrs;
   const auto& join_hash_tables = plan_state_->join_info_.join_hash_tables_;
   for (auto hash_table : join_hash_tables) {
     if (!hash_table) {
       CHECK(table_ptrs.empty());
       return {};
     }
     table_ptrs.push_back(hash_table->getJoinHashBuffer(
         device_type, device_type == ExecutorDeviceType::GPU ? device_id : 0));
   }
   return table_ptrs;
 }

Here is the call graph for this function:

size_t Executor::getNumBytesForFetchedRow ( ) const

Definition at line 261 of file Execute.cpp.

References catalog_(), kENCODING_DICT, and kTEXT.

                                                 {
   size_t num_bytes = 0;
   if (!plan_state_) {
     return 0;
   }
   for (const auto& fetched_col_pair : plan_state_->columns_to_fetch_) {
     if (fetched_col_pair.first < 0) {
       num_bytes += 8;
     } else {
       const auto cd =
           catalog_->getMetadataForColumn(fetched_col_pair.first, fetched_col_pair.second);
       const auto& ti = cd->columnType;
       const auto sz = ti.get_type() == kTEXT && ti.get_compression() == kENCODING_DICT
                           ? 4
                           : ti.get_size();
       if (sz < 0) {
         // for varlen types, only account for the pointer/size for each row, for now
         num_bytes += 16;
       } else {
         num_bytes += sz;
       }
     }
   }
   return num_bytes;
 }

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation