#include "Execute.h"
#include "AggregateUtils.h"
#include "BaselineJoinHashTable.h"
#include "CodeGenerator.h"
#include "ColumnFetcher.h"
#include "Descriptors/QueryCompilationDescriptor.h"
#include "Descriptors/QueryFragmentDescriptor.h"
#include "DynamicWatchdog.h"
#include "EquiJoinCondition.h"
#include "ErrorHandling.h"
#include "ExpressionRewrite.h"
#include "ExternalCacheInvalidators.h"
#include "GpuMemUtils.h"
#include "InPlaceSort.h"
#include "JsonAccessors.h"
#include "OutputBufferInitialization.h"
#include "OverlapsJoinHashTable.h"
#include "QueryRewrite.h"
#include "QueryTemplateGenerator.h"
#include "ResultSetReductionJIT.h"
#include "RuntimeFunctions.h"
#include "SpeculativeTopN.h"
#include "TableFunctions/TableFunctionCompilationContext.h"
#include "TableFunctions/TableFunctionExecutionContext.h"
#include "CudaMgr/CudaMgr.h"
#include "DataMgr/BufferMgr/BufferMgr.h"
#include "Parser/ParserNode.h"
#include "Shared/ExperimentalTypeUtilities.h"
#include "Shared/MapDParameters.h"
#include "Shared/TypedDataAccessors.h"
#include "Shared/checked_alloc.h"
#include "Shared/measure.h"
#include "Shared/scope.h"
#include "Shared/shard_key.h"
#include "AggregatedColRange.h"
#include "StringDictionaryGenerations.h"
#include <llvm/Transforms/Utils/BasicBlockUtils.h>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <future>
#include <memory>
#include <numeric>
#include <set>
#include <thread>
#include "ArrayOps.cpp"
#include "DateAdd.cpp"
#include "StringFunctions.cpp"

Include dependency graph for Execute.cpp:

Classes
class	anonymous_namespace{Execute.cpp}::OutVecOwner

class	AggregateReductionEgress< META_TYPE_CLASS >

class	AggregateReductionEgress< Experimental::MetaTypeClass< Experimental::Geometry > >

Namespaces
	anonymous_namespace{Execute.cpp}

	Importer_NS

Macros
#define	EXECUTE_INCLUDE

Functions
ResultSetPtr	anonymous_namespace{Execute.cpp}::get_merged_result (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device)

std::unordered_set< int >	get_available_gpus (const Catalog_Namespace::Catalog &cat)

size_t	get_context_count (const ExecutorDeviceType device_type, const size_t cpu_count, const size_t gpu_count)

size_t	anonymous_namespace{Execute.cpp}::compute_buffer_entry_guess (const std::vector< InputTableInfo > &query_infos)

std::string	anonymous_namespace{Execute.cpp}::get_table_name (const InputDescriptor &input_desc, const Catalog_Namespace::Catalog &cat)

size_t	anonymous_namespace{Execute.cpp}::getDeviceBasedScanLimit (const ExecutorDeviceType device_type, const int device_count)

void	anonymous_namespace{Execute.cpp}::checkWorkUnitWatchdog (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &table_infos, const Catalog_Namespace::Catalog &cat, const ExecutorDeviceType device_type, const int device_count)

bool	is_trivial_loop_join (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)

RelAlgExecutionUnit	anonymous_namespace{Execute.cpp}::replace_scan_limit (const RelAlgExecutionUnit &ra_exe_unit_in, const size_t new_scan_limit)

int64_t	anonymous_namespace{Execute.cpp}::inline_null_val (const SQLTypeInfo &ti, const bool float_argument_input)

void	anonymous_namespace{Execute.cpp}::fill_entries_for_empty_input (std::vector< TargetInfo > &target_infos, std::vector< int64_t > &entry, const std::vector< Analyzer::Expr *> &target_exprs, const QueryMemoryDescriptor &query_mem_desc)

ResultSetPtr	anonymous_namespace{Execute.cpp}::build_row_for_empty_input (const std::vector< Analyzer::Expr *> &target_exprs_in, const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type)

size_t	anonymous_namespace{Execute.cpp}::permute_storage_columnar (const ResultSetStorage input_storage, const QueryMemoryDescriptor &input_query_mem_desc, const ResultSetStorage output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)

size_t	anonymous_namespace{Execute.cpp}::permute_storage_row_wise (const ResultSetStorage input_storage, const ResultSetStorage output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)

bool	anonymous_namespace{Execute.cpp}::has_lazy_fetched_columns (const std::vector< ColumnLazyFetchInfo > &fetched_cols)

const ColumnDescriptor *	anonymous_namespace{Execute.cpp}::try_get_column_descriptor (const InputColDescriptor *col_desc, const Catalog_Namespace::Catalog &cat)

std::map< size_t, std::vector< uint64_t > >	get_table_id_to_frag_offsets (const std::vector< InputDescriptor > &input_descs, const std::map< int, const TableFragments *> &all_tables_fragments)

bool	anonymous_namespace{Execute.cpp}::check_rows_less_than_needed (const ResultSetPtr &results, const size_t scan_limit)

template<class T >
int64_t	anonymous_namespace{Execute.cpp}::insert_one_dict_str (T col_data, const std::string &columnName, const SQLTypeInfo &columnType, const Analyzer::Constant col_cv, const Catalog_Namespace::Catalog &catalog)

template<class T >
int64_t	anonymous_namespace{Execute.cpp}::insert_one_dict_str (T col_data, const ColumnDescriptor cd, const Analyzer::Constant *col_cv, const Catalog_Namespace::Catalog &catalog)

int8_t *	Importer_NS::appendDatum (int8_t *buf, Datum d, const SQLTypeInfo &ti)

int64_t	anonymous_namespace{Execute.cpp}::get_hpt_scaled_value (const int64_t &val, const int32_t &ldim, const int32_t &rdim)

Variables
bool	g_enable_watchdog {false}

bool	g_enable_dynamic_watchdog {false}

unsigned	g_dynamic_watchdog_time_limit {10000}

bool	g_allow_cpu_retry {true}

bool	g_null_div_by_zero {false}

unsigned	g_trivial_loop_join_threshold {1000}

bool	g_from_table_reordering {true}

bool	g_inner_join_fragment_skipping {true}

bool	g_enable_smem_group_by

std::unique_ptr< llvm::Module >	udf_gpu_module

std::unique_ptr< llvm::Module >	udf_cpu_module

bool	g_enable_filter_push_down {false}

float	g_filter_push_down_low_frac {-1.0f}

float	g_filter_push_down_high_frac {-1.0f}

size_t	g_filter_push_down_passing_row_ubound {0}

bool	g_enable_columnar_output {false}

bool	g_enable_overlaps_hashjoin {false}

bool	g_cache_string_hash {false}

size_t	g_overlaps_max_table_size_bytes {1024 * 1024 * 1024}

bool	g_strip_join_covered_quals {false}

size_t	g_constrained_by_in_threshold {10}

size_t	g_big_group_threshold {20000}

bool	g_enable_window_functions {true}

bool	g_enable_table_functions {false}

size_t	g_max_memory_allocation_size {2000000000}

size_t	g_min_memory_allocation_size

bool	g_enable_bump_allocator {false}

double	g_bump_allocator_step_reduction {0.75}

bool	g_enable_direct_columnarization {true}

bool	g_enable_experimental_string_functions

Macro Definition Documentation

◆ EXECUTE_INCLUDE

#define EXECUTE_INCLUDE

Definition at line 3046 of file Execute.cpp.

Function Documentation

◆ get_available_gpus()

std::unordered_set<int> get_available_gpus ( const Catalog_Namespace::Catalog & cat )

Definition at line 957 of file Execute.cpp.

References CHECK_GT, Data_Namespace::DataMgr::getCudaMgr(), Catalog_Namespace::Catalog::getDataMgr(), CudaMgr_Namespace::CudaMgr::getDeviceCount(), and Data_Namespace::DataMgr::gpusPresent().

Referenced by Executor::executeWorkUnitImpl(), and is_unnest().

                                                                               {
   std::unordered_set<int> available_gpus;
   if (cat.getDataMgr().gpusPresent()) {
     int gpu_count = cat.getDataMgr().getCudaMgr()->getDeviceCount();
     CHECK_GT(gpu_count, 0);
     for (int gpu_id = 0; gpu_id < gpu_count; ++gpu_id) {
       available_gpus.insert(gpu_id);
     }
   }
   return available_gpus;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_context_count()

size_t get_context_count	(	const ExecutorDeviceType	device_type,
		const size_t	cpu_count,
		const size_t	gpu_count
	)

Definition at line 969 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl(), and is_unnest().

                                                  {
   return device_type == ExecutorDeviceType::GPU ? gpu_count
                                                 : static_cast<size_t>(cpu_count);
 }

Here is the caller graph for this function:

◆ get_table_id_to_frag_offsets()

std::map<size_t, std::vector<uint64_t> > get_table_id_to_frag_offsets	(	const std::vector< InputDescriptor > &	input_descs,
		const std::map< int, const TableFragments *> &	all_tables_fragments
	)

Definition at line 1939 of file Execute.cpp.

References CHECK.

Referenced by Executor::getRowCountAndOffsetForAllFrags().

                                                                     {
   std::map<size_t, std::vector<uint64_t>> tab_id_to_frag_offsets;
   for (auto& desc : input_descs) {
     const auto fragments_it = all_tables_fragments.find(desc.getTableId());
     CHECK(fragments_it != all_tables_fragments.end());
     const auto& fragments = *fragments_it->second;
     std::vector<uint64_t> frag_offsets(fragments.size(), 0);
     for (size_t i = 0, off = 0; i < fragments.size(); ++i) {
       frag_offsets[i] = off;
       off += fragments[i].getNumTuples();
     }
     tab_id_to_frag_offsets.insert(std::make_pair(desc.getTableId(), frag_offsets));
   }
   return tab_id_to_frag_offsets;
 }

Here is the caller graph for this function:

◆ is_trivial_loop_join()

bool is_trivial_loop_join	(	const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

Definition at line 1077 of file Execute.cpp.

References CHECK_NE, g_trivial_loop_join_threshold, and RelAlgExecutionUnit::input_descs.

Referenced by anonymous_namespace{IRCodegen.cpp}::check_if_loop_join_is_allowed(), and is_unnest().

                                                                   {
   if (ra_exe_unit.input_descs.size() < 2) {
     return false;
   }
 
   // We only support loop join at the end of folded joins
   // where ra_exe_unit.input_descs.size() > 2 for now.
   const auto inner_table_id = ra_exe_unit.input_descs.back().getTableId();
 
   ssize_t inner_table_idx = -1;
   for (size_t i = 0; i < query_infos.size(); ++i) {
     if (query_infos[i].table_id == inner_table_id) {
       inner_table_idx = i;
       break;
     }
   }
   CHECK_NE(ssize_t(-1), inner_table_idx);
   return query_infos[inner_table_idx].info.getNumTuples() <=
          g_trivial_loop_join_threshold;
 }