OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Execute.cpp File Reference
#include "QueryEngine/Execute.h"
#include <llvm/Transforms/Utils/BasicBlockUtils.h>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <chrono>
#include <ctime>
#include <future>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <set>
#include <thread>
#include "Catalog/Catalog.h"
#include "CudaMgr/CudaMgr.h"
#include "DataMgr/BufferMgr/BufferMgr.h"
#include "DataMgr/ForeignStorage/FsiChunkUtils.h"
#include "OSDependent/heavyai_path.h"
#include "Parser/ParserNode.h"
#include "QueryEngine/AggregateUtils.h"
#include "QueryEngine/AggregatedColRange.h"
#include "QueryEngine/CodeGenerator.h"
#include "QueryEngine/ColumnFetcher.h"
#include "QueryEngine/Descriptors/QueryCompilationDescriptor.h"
#include "QueryEngine/Descriptors/QueryFragmentDescriptor.h"
#include "QueryEngine/DynamicWatchdog.h"
#include "QueryEngine/EquiJoinCondition.h"
#include "QueryEngine/ErrorHandling.h"
#include "QueryEngine/ExecutorResourceMgr/ExecutorResourceMgr.h"
#include "QueryEngine/ExpressionRewrite.h"
#include "QueryEngine/ExternalCacheInvalidators.h"
#include "QueryEngine/GpuMemUtils.h"
#include "QueryEngine/InPlaceSort.h"
#include "QueryEngine/JoinHashTable/BaselineJoinHashTable.h"
#include "QueryEngine/JoinHashTable/BoundingBoxIntersectJoinHashTable.h"
#include "QueryEngine/JsonAccessors.h"
#include "QueryEngine/OutputBufferInitialization.h"
#include "QueryEngine/QueryDispatchQueue.h"
#include "QueryEngine/QueryEngine.h"
#include "QueryEngine/QueryRewrite.h"
#include "QueryEngine/QueryTemplateGenerator.h"
#include "QueryEngine/ResultSetReductionJIT.h"
#include "QueryEngine/RuntimeFunctions.h"
#include "QueryEngine/SpeculativeTopN.h"
#include "QueryEngine/StringDictionaryGenerations.h"
#include "QueryEngine/TableFunctions/TableFunctionCompilationContext.h"
#include "QueryEngine/TableFunctions/TableFunctionExecutionContext.h"
#include "QueryEngine/Visitors/TransientStringLiteralsVisitor.h"
#include "Shared/SystemParameters.h"
#include "Shared/TypedDataAccessors.h"
#include "Shared/checked_alloc.h"
#include "Shared/measure.h"
#include "Shared/misc.h"
#include "Shared/scope.h"
#include "Shared/shard_key.h"
#include "Shared/threading.h"
#include "ArrayOps.cpp"
#include "DateAdd.cpp"
#include "GeoOps.cpp"
#include "RowFunctionOps.cpp"
#include "StringFunctions.cpp"
#include "TableFunctions/TableFunctionOps.cpp"

Go to the source code of this file.

Classes

struct  anonymous_namespace{Execute.cpp}::GetTargetInfo
 
class  anonymous_namespace{Execute.cpp}::OutVecOwner
 

Namespaces

 anonymous_namespace{Execute.cpp}
 
 foreign_storage
 

Macros

#define EXECUTE_INCLUDE
 

Functions

std::unique_ptr< llvm::Module > read_llvm_module_from_bc_file (const std::string &udf_ir_filename, llvm::LLVMContext &ctx)
 
std::unique_ptr< llvm::Module > read_llvm_module_from_ir_file (const std::string &udf_ir_filename, llvm::LLVMContext &ctx, bool is_gpu=false)
 
std::unique_ptr< llvm::Module > read_llvm_module_from_ir_string (const std::string &udf_ir_string, llvm::LLVMContext &ctx, bool is_gpu=false)
 
void anonymous_namespace{Execute.cpp}::prepare_string_dictionaries (const std::unordered_set< PhysicalInput > &phys_inputs)
 
bool anonymous_namespace{Execute.cpp}::is_empty_table (Fragmenter_Namespace::AbstractFragmenter *fragmenter)
 
void foreign_storage::populate_string_dictionary (int32_t table_id, int32_t col_id, int32_t db_id)
 
 block_size_x_ (block_size_x)
 
 grid_size_x_ (grid_size_x)
 
 max_gpu_slab_size_ (max_gpu_slab_size)
 
 debug_dir_ (debug_dir)
 
 debug_file_ (debug_file)
 
 data_mgr_ (data_mgr)
 
 temporary_tables_ (nullptr)
 
 input_table_info_cache_ (this)
 
void anonymous_namespace{Execute.cpp}::log_system_memory_info_impl (std::string const &mem_log, size_t executor_id, size_t log_time_ms, std::string const &log_tag, size_t const thread_idx)
 
size_t anonymous_namespace{Execute.cpp}::get_col_byte_width (const shared::ColumnKey &column_key)
 
ResultSetPtr anonymous_namespace{Execute.cpp}::get_merged_result (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device, std::vector< TargetInfo > const &targets)
 
ReductionCode anonymous_namespace{Execute.cpp}::get_reduction_code (const size_t executor_id, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device, int64_t *compilation_queue_time)
 
std::unordered_set< int > get_available_gpus (const Data_Namespace::DataMgr *data_mgr)
 
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, const RelAlgExecutionUnit &ra_exe_unit)
 
std::string anonymous_namespace{Execute.cpp}::get_table_name (const InputDescriptor &input_desc)
 
size_t anonymous_namespace{Execute.cpp}::getDeviceBasedWatchdogScanLimit (size_t watchdog_max_projected_rows_per_device, 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 ExecutorDeviceType device_type, const int device_count)
 
size_t get_loop_join_size (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
 
template<typename T >
std::vector< std::string > anonymous_namespace{Execute.cpp}::expr_container_to_string (const T &expr_container)
 
template<>
std::vector< std::string > anonymous_namespace{Execute.cpp}::expr_container_to_string (const std::list< Analyzer::OrderEntry > &expr_container)
 
std::string anonymous_namespace{Execute.cpp}::sort_algorithm_to_string (const SortAlgorithm algorithm)
 
std::ostream & operator<< (std::ostream &os, 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 ColumnDescriptoranonymous_namespace{Execute.cpp}::try_get_column_descriptor (const InputColDescriptor *col_desc)
 
std::map< shared::TableKey,
std::vector< uint64_t > > 
get_table_id_to_frag_offsets (const std::vector< InputDescriptor > &input_descs, const std::map< shared::TableKey, const TableFragments * > &all_tables_fragments)
 
std::ostream & operator<< (std::ostream &os, FetchResult const &fetch_result)
 
size_t anonymous_namespace{Execute.cpp}::get_selected_input_descs_index (const shared::TableKey &table_key, std::vector< InputDescriptor > const &input_descs)
 
size_t anonymous_namespace{Execute.cpp}::get_selected_input_col_descs_index (const shared::TableKey &table_key, std::list< std::shared_ptr< InputColDescriptor const >> const &input_col_descs)
 
std::list< std::shared_ptr
< const InputColDescriptor > > 
anonymous_namespace{Execute.cpp}::get_selected_input_col_descs (const shared::TableKey &table_key, std::list< std::shared_ptr< InputColDescriptor const >> const &input_col_descs)
 
void anonymous_namespace{Execute.cpp}::set_mod_range (std::vector< int8_t const * > &frag_col_buffers, int8_t const *const ptr, size_t const local_col_id, size_t const N)
 
bool anonymous_namespace{Execute.cpp}::check_rows_less_than_needed (const ResultSetPtr &results, const size_t scan_limit)
 
void anonymous_namespace{Execute.cpp}::add_deleted_col_to_map (PlanState::DeletedColumnsMap &deleted_cols_map, const ColumnDescriptor *deleted_cd, const shared::TableKey &table_key)
 
std::tuple< bool, int64_t,
int64_t > 
anonymous_namespace{Execute.cpp}::get_hpt_overflow_underflow_safe_scaled_values (const int64_t chunk_min, const int64_t chunk_max, const SQLTypeInfo &lhs_type, const SQLTypeInfo &rhs_type)
 

Variables

bool g_enable_watchdog false
 
bool g_enable_dynamic_watchdog {false}
 
size_t g_watchdog_none_encoded_string_translation_limit {1000000UL}
 
size_t g_watchdog_max_projected_rows_per_device {128000000}
 
size_t g_preflight_count_query_threshold {1000000}
 
bool g_enable_cpu_sub_tasks {false}
 
size_t g_cpu_sub_task_size {500'000}
 
bool g_enable_filter_function {true}
 
unsigned g_dynamic_watchdog_time_limit {10000}
 
bool g_allow_cpu_retry {true}
 
bool g_allow_query_step_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_left_join_filter_hoisting {true}
 
bool g_optimize_row_initialization {true}
 
bool g_enable_bbox_intersect_hashjoin {true}
 
size_t g_num_tuple_threshold_switch_to_baseline {100000}
 
size_t g_ratio_num_hash_entry_to_num_tuple_switch_to_baseline {100}
 
bool g_enable_distance_rangejoin {true}
 
bool g_enable_hashjoin_many_to_many {true}
 
size_t g_bbox_intersect_max_table_size_bytes {1024 * 1024 * 1024}
 
double g_bbox_intersect_target_entries_per_bin {1.3}
 
bool g_strip_join_covered_quals {false}
 
size_t g_constrained_by_in_threshold {10}
 
size_t g_default_max_groups_buffer_entry_guess {16384}
 
size_t g_big_group_threshold {g_default_max_groups_buffer_entry_guess}
 
bool g_enable_window_functions {true}
 
bool g_enable_table_functions {true}
 
bool g_enable_ml_functions {true}
 
bool g_restrict_ml_model_metadata_to_superusers {false}
 
bool g_enable_dev_table_functions {false}
 
bool g_enable_geo_ops_on_uncompressed_coords {true}
 
bool g_enable_rf_prop_table_functions {true}
 
bool g_allow_memory_status_log {true}
 
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_string_functions
 
bool g_enable_lazy_fetch {true}
 
bool g_enable_runtime_query_interrupt {true}
 
bool g_enable_non_kernel_time_query_interrupt {true}
 
bool g_use_estimator_result_cache {true}
 
unsigned g_pending_query_interrupt_freq {1000}
 
double g_running_query_interrupt_freq {0.1}
 
size_t g_gpu_smem_threshold
 
bool g_enable_smem_grouped_non_count_agg
 
bool g_enable_smem_non_grouped_agg
 
bool g_is_test_env {false}
 
size_t g_enable_parallel_linearization
 
bool g_enable_data_recycler {true}
 
bool g_use_hashtable_cache {true}
 
bool g_use_query_resultset_cache {true}
 
bool g_use_chunk_metadata_cache {true}
 
bool g_allow_auto_resultset_caching {false}
 
bool g_allow_query_step_skipping {true}
 
size_t g_hashtable_cache_total_bytes {size_t(1) << 32}
 
size_t g_max_cacheable_hashtable_size_bytes {size_t(1) << 31}
 
size_t g_query_resultset_cache_total_bytes {size_t(1) << 32}
 
size_t g_max_cacheable_query_resultset_size_bytes {size_t(1) << 31}
 
size_t g_auto_resultset_caching_threshold {size_t(1) << 20}
 
bool g_optimize_cuda_block_and_grid_sizes {false}
 
size_t g_approx_quantile_buffer {1000}
 
size_t g_approx_quantile_centroids {300}
 
bool g_enable_automatic_ir_metadata {true}
 
size_t g_max_log_length {500}
 
bool g_enable_executor_resource_mgr {true}
 
double g_executor_resource_mgr_cpu_result_mem_ratio {0.8}
 
size_t g_executor_resource_mgr_cpu_result_mem_bytes {Executor::auto_cpu_mem_bytes}
 
double g_executor_resource_mgr_per_query_max_cpu_slots_ratio {0.9}
 
double g_executor_resource_mgr_per_query_max_cpu_result_mem_ratio {0.8}
 
bool g_executor_resource_mgr_allow_cpu_kernel_concurrency {true}
 
bool g_executor_resource_mgr_allow_cpu_gpu_kernel_concurrency {true}
 
bool g_executor_resource_mgr_allow_cpu_slot_oversubscription_concurrency {false}
 
bool g_executor_resource_mgr_allow_cpu_result_mem_oversubscription_concurrency {false}
 
double g_executor_resource_mgr_max_available_resource_use_ratio {0.8}
 
bool g_cache_string_hash
 
 this
 

Macro Definition Documentation

#define EXECUTE_INCLUDE

Definition at line 4419 of file Execute.cpp.

Function Documentation

block_size_x_ ( block_size_x  )
debug_dir_ ( debug_dir  )
debug_file_ ( debug_file  )
std::unordered_set<int> get_available_gpus ( const Data_Namespace::DataMgr data_mgr)

Definition at line 1727 of file Execute.cpp.

References CHECK, CHECK_GT, Data_Namespace::DataMgr::getCudaMgr(), CudaMgr_Namespace::CudaMgr::getDeviceCount(), and Data_Namespace::DataMgr::gpusPresent().

Referenced by Executor::executeWorkUnitImpl().

1727  {
1728  CHECK(data_mgr);
1729  std::unordered_set<int> available_gpus;
1730  if (data_mgr->gpusPresent()) {
1731  CHECK(data_mgr->getCudaMgr());
1732  const int gpu_count = data_mgr->getCudaMgr()->getDeviceCount();
1733  CHECK_GT(gpu_count, 0);
1734  for (int gpu_id = 0; gpu_id < gpu_count; ++gpu_id) {
1735  available_gpus.insert(gpu_id);
1736  }
1737  }
1738  return available_gpus;
1739 }
CudaMgr_Namespace::CudaMgr * getCudaMgr() const
Definition: DataMgr.h:235
#define CHECK_GT(x, y)
Definition: Logger.h:305
int getDeviceCount() const
Definition: CudaMgr.h:90
#define CHECK(condition)
Definition: Logger.h:291
bool gpusPresent() const
Definition: DataMgr.h:228

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 1741 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl().

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

+ Here is the caller graph for this function:

size_t get_loop_join_size ( const std::vector< InputTableInfo > &  query_infos,
const RelAlgExecutionUnit ra_exe_unit 
)

Definition at line 1880 of file Execute.cpp.

References CHECK, and RelAlgExecutionUnit::input_descs.

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

1881  {
1882  const auto inner_table_key = ra_exe_unit.input_descs.back().getTableKey();
1883 
1884  std::optional<size_t> inner_table_idx;
1885  for (size_t i = 0; i < query_infos.size(); ++i) {
1886  if (query_infos[i].table_key == inner_table_key) {
1887  inner_table_idx = i;
1888  break;
1889  }
1890  }
1891  CHECK(inner_table_idx);
1892  return query_infos[*inner_table_idx].info.getNumTuples();
1893 }
std::vector< InputDescriptor > input_descs
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the caller graph for this function:

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

Definition at line 3316 of file Execute.cpp.

References CHECK.

Referenced by Executor::getRowCountAndOffsetForAllFrags().

3318  {
3319  std::map<shared::TableKey, std::vector<uint64_t>> tab_id_to_frag_offsets;
3320  for (auto& desc : input_descs) {
3321  const auto fragments_it = all_tables_fragments.find(desc.getTableKey());
3322  CHECK(fragments_it != all_tables_fragments.end());
3323  const auto& fragments = *fragments_it->second;
3324  std::vector<uint64_t> frag_offsets(fragments.size(), 0);
3325  for (size_t i = 0, off = 0; i < fragments.size(); ++i) {
3326  frag_offsets[i] = off;
3327  off += fragments[i].getNumTuples();
3328  }
3329  tab_id_to_frag_offsets.insert(std::make_pair(desc.getTableKey(), frag_offsets));
3330  }
3331  return tab_id_to_frag_offsets;
3332 }
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the caller graph for this function:

grid_size_x_ ( grid_size_x  )
input_table_info_cache_ ( this  )

Definition at line 289 of file Execute.cpp.

References Executor::initialize_extension_module_sources().

289  {
291  update_extension_modules();
292 }
static void initialize_extension_module_sources()
Definition: Execute.cpp:294

+ Here is the call graph for this function:

max_gpu_slab_size_ ( max_gpu_slab_size  )
std::ostream& operator<< ( std::ostream &  os,
const RelAlgExecutionUnit ra_exe_unit 
)

Definition at line 1999 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, anonymous_namespace{Execute.cpp}::expr_container_to_string(), RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::input_col_descs, join(), RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::query_plan_dag_hash, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::simple_quals, anonymous_namespace{Execute.cpp}::sort_algorithm_to_string(), RelAlgExecutionUnit::sort_info, RelAlgExecutionUnit::target_exprs, to_string(), toString(), RelAlgExecutionUnit::union_all, and RelAlgExecutionUnit::use_bump_allocator.

1999  {
2000  os << "\n\tExtracted Query Plan Dag Hash: " << ra_exe_unit.query_plan_dag_hash;
2001  os << "\n\tTable/Col/Levels: ";
2002  for (const auto& input_col_desc : ra_exe_unit.input_col_descs) {
2003  const auto& scan_desc = input_col_desc->getScanDesc();
2004  os << "(" << scan_desc.getTableKey() << ", " << input_col_desc->getColId() << ", "
2005  << scan_desc.getNestLevel() << ") ";
2006  }
2007  if (!ra_exe_unit.simple_quals.empty()) {
2008  os << "\n\tSimple Quals: "
2010  ", ");
2011  }
2012  if (!ra_exe_unit.quals.empty()) {
2013  os << "\n\tQuals: "
2014  << boost::algorithm::join(expr_container_to_string(ra_exe_unit.quals), ", ");
2015  }
2016  if (!ra_exe_unit.join_quals.empty()) {
2017  os << "\n\tJoin Quals: ";
2018  for (size_t i = 0; i < ra_exe_unit.join_quals.size(); i++) {
2019  const auto& join_condition = ra_exe_unit.join_quals[i];
2020  os << "\t\t" << std::to_string(i) << " " << ::toString(join_condition.type);
2021  os << boost::algorithm::join(expr_container_to_string(join_condition.quals), ", ");
2022  }
2023  }
2024  if (!ra_exe_unit.groupby_exprs.empty()) {
2025  os << "\n\tGroup By: "
2027  ", ");
2028  }
2029  os << "\n\tProjected targets: "
2031  os << "\n\tHas Estimator: " << ::toString(ra_exe_unit.estimator == nullptr);
2032  os << "\n\tSort Info: ";
2033  const auto& sort_info = ra_exe_unit.sort_info;
2034  os << "\n\t Order Entries: "
2035  << boost::algorithm::join(expr_container_to_string(sort_info.order_entries), ", ");
2036  os << "\n\t Algorithm: " << sort_algorithm_to_string(sort_info.algorithm);
2037  std::string limit_str = sort_info.limit ? std::to_string(*sort_info.limit) : "N/A";
2038  os << "\n\t Limit: " << limit_str;
2039  os << "\n\t Offset: " << std::to_string(sort_info.offset);
2040  os << "\n\tScan Limit: " << std::to_string(ra_exe_unit.scan_limit);
2041  os << "\n\tBump Allocator: " << ::toString(ra_exe_unit.use_bump_allocator);
2042  if (ra_exe_unit.union_all) {
2043  os << "\n\tUnion: " << std::string(*ra_exe_unit.union_all ? "UNION ALL" : "UNION");
2044  }
2045  return os;
2046 }
std::vector< Analyzer::Expr * > target_exprs
QueryPlanHash query_plan_dag_hash
const std::optional< bool > union_all
std::string join(T const &container, std::string const &delim)
std::string toString(const QueryDescriptionType &type)
Definition: Types.h:64
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
std::string to_string(char const *&&v)
const JoinQualsPerNestingLevel join_quals
std::vector< std::string > expr_container_to_string(const T &expr_container)
Definition: Execute.cpp:1898
const std::shared_ptr< Analyzer::Estimator > estimator
std::string sort_algorithm_to_string(const SortAlgorithm algorithm)
Definition: Execute.cpp:1920
std::list< std::shared_ptr< Analyzer::Expr > > quals
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals

+ Here is the call graph for this function:

std::ostream& operator<< ( std::ostream &  os,
FetchResult const &  fetch_result 
)

Definition at line 3420 of file Execute.cpp.

References FetchResult::col_buffers, FetchResult::frag_offsets, FetchResult::num_rows, and shared::printContainer().

3420  {
3421  return os << "col_buffers" << shared::printContainer(fetch_result.col_buffers)
3422  << " num_rows" << shared::printContainer(fetch_result.num_rows)
3423  << " frag_offsets" << shared::printContainer(fetch_result.frag_offsets);
3424 }
PrintContainer< CONTAINER > printContainer(CONTAINER &container)
Definition: misc.h:107

+ Here is the call graph for this function:

std::unique_ptr<llvm::Module> read_llvm_module_from_bc_file ( const std::string &  udf_ir_filename,
llvm::LLVMContext &  ctx 
)

Definition at line 1587 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1589  {
1590  llvm::SMDiagnostic err;
1591 
1592  auto buffer_or_error = llvm::MemoryBuffer::getFile(bc_filename);
1593  CHECK(!buffer_or_error.getError()) << "bc_filename=" << bc_filename;
1594  llvm::MemoryBuffer* buffer = buffer_or_error.get().get();
1595 
1596  auto owner = llvm::parseBitcodeFile(buffer->getMemBufferRef(), context);
1597  CHECK(!owner.takeError());
1598  CHECK(owner->get());
1599  return std::move(owner.get());
1600 }
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the caller graph for this function:

std::unique_ptr<llvm::Module> read_llvm_module_from_ir_file ( const std::string &  udf_ir_filename,
llvm::LLVMContext &  ctx,
bool  is_gpu = false 
)

Definition at line 1602 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1605  {
1606  llvm::SMDiagnostic parse_error;
1607 
1608  llvm::StringRef file_name_arg(udf_ir_filename);
1609 
1610  auto owner = llvm::parseIRFile(file_name_arg, parse_error, ctx);
1611  if (!owner) {
1612  throw_parseIR_error(parse_error, udf_ir_filename, is_gpu);
1613  }
1614 
1615  if (is_gpu) {
1616  llvm::Triple gpu_triple(owner->getTargetTriple());
1617  if (!gpu_triple.isNVPTX()) {
1618  LOG(WARNING)
1619  << "Expected triple nvptx64-nvidia-cuda for NVVM IR of loadtime UDFs but got "
1620  << gpu_triple.str() << ". Disabling the NVVM IR module.";
1621  return std::unique_ptr<llvm::Module>();
1622  }
1623  }
1624  return owner;
1625 }
#define LOG(tag)
Definition: Logger.h:285
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)

+ Here is the caller graph for this function:

std::unique_ptr<llvm::Module> read_llvm_module_from_ir_string ( const std::string &  udf_ir_string,
llvm::LLVMContext &  ctx,
bool  is_gpu = false 
)

Definition at line 1627 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1630  {
1631  llvm::SMDiagnostic parse_error;
1632 
1633  auto buf = std::make_unique<llvm::MemoryBufferRef>(udf_ir_string,
1634  "Runtime UDF/UDTF LLVM/NVVM IR");
1635 
1636  auto owner = llvm::parseIR(*buf, parse_error, ctx);
1637  if (!owner) {
1638  LOG(IR) << "read_llvm_module_from_ir_string:\n"
1639  << udf_ir_string << "\nEnd of LLVM/NVVM IR";
1640  throw_parseIR_error(parse_error, "", /* is_gpu= */ is_gpu);
1641  }
1642 
1643  if (is_gpu) {
1644  llvm::Triple gpu_triple(owner->getTargetTriple());
1645  if (!gpu_triple.isNVPTX()) {
1646  LOG(IR) << "read_llvm_module_from_ir_string:\n"
1647  << udf_ir_string << "\nEnd of NNVM IR";
1648  LOG(WARNING) << "Expected triple nvptx64-nvidia-cuda for NVVM IR but got "
1649  << gpu_triple.str()
1650  << ". Executing runtime UDF/UDTFs on GPU will be disabled.";
1651  return std::unique_ptr<llvm::Module>();
1652  ;
1653  }
1654  }
1655  return owner;
1656 }
#define LOG(tag)
Definition: Logger.h:285
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)

+ Here is the caller graph for this function:

temporary_tables_ ( nullptr  )

Variable Documentation

false

Definition at line 80 of file Execute.cpp.

bool g_allow_query_step_cpu_retry {true}
size_t g_approx_quantile_buffer {1000}
size_t g_approx_quantile_centroids {300}
size_t g_auto_resultset_caching_threshold {size_t(1) << 20}
size_t g_bbox_intersect_max_table_size_bytes {1024 * 1024 * 1024}
double g_bbox_intersect_target_entries_per_bin {1.3}
size_t g_big_group_threshold {g_default_max_groups_buffer_entry_guess}

Definition at line 115 of file Execute.cpp.

Referenced by RelAlgExecutor::executeWorkUnit().

double g_bump_allocator_step_reduction {0.75}

Definition at line 129 of file Execute.cpp.

Referenced by create_dev_group_by_buffers().

bool g_cache_string_hash

Definition at line 53 of file StringDictionary.cpp.

size_t g_constrained_by_in_threshold {10}

Definition at line 113 of file Execute.cpp.

Referenced by QueryRewriter::rewriteConstrainedByInImpl().

size_t g_cpu_sub_task_size {500'000}
unsigned g_dynamic_watchdog_time_limit {10000}
bool g_enable_automatic_ir_metadata {true}
bool g_enable_bump_allocator {false}
bool g_enable_cpu_sub_tasks {false}
bool g_enable_dev_table_functions {false}
bool g_enable_direct_columnarization {true}
bool g_enable_distance_rangejoin {true}

Definition at line 108 of file Execute.cpp.

Referenced by convert_bbox_intersect_join(), and CommandLineOptions::fillOptions().

bool g_enable_filter_function {true}

Definition at line 87 of file Execute.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions().

bool g_enable_geo_ops_on_uncompressed_coords {true}
bool g_enable_hashjoin_many_to_many {true}
bool g_enable_left_join_filter_hoisting {true}
size_t g_enable_parallel_linearization
Initial value:
{
10000}

Definition at line 152 of file Execute.cpp.

Referenced by ColumnFetcher::linearizeVarLenArrayColFrags().

bool g_enable_rf_prop_table_functions {true}

Definition at line 122 of file Execute.cpp.

bool g_enable_smem_group_by
bool g_enable_smem_grouped_non_count_agg
Initial value:
{
true}

Definition at line 143 of file Execute.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions().

bool g_enable_smem_non_grouped_agg
Initial value:
{
true}

Definition at line 146 of file Execute.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions().

bool g_enable_string_functions

Definition at line 40 of file RelAlgTranslator.cpp.

bool g_enable_window_functions {true}
bool g_executor_resource_mgr_allow_cpu_gpu_kernel_concurrency {true}
bool g_executor_resource_mgr_allow_cpu_kernel_concurrency {true}
bool g_executor_resource_mgr_allow_cpu_result_mem_oversubscription_concurrency {false}
bool g_executor_resource_mgr_allow_cpu_slot_oversubscription_concurrency {false}
size_t g_executor_resource_mgr_cpu_result_mem_bytes {Executor::auto_cpu_mem_bytes}
double g_executor_resource_mgr_cpu_result_mem_ratio {0.8}
double g_executor_resource_mgr_max_available_resource_use_ratio {0.8}
double g_executor_resource_mgr_per_query_max_cpu_result_mem_ratio {0.8}
double g_executor_resource_mgr_per_query_max_cpu_slots_ratio {0.9}
float g_filter_push_down_high_frac {-1.0f}
float g_filter_push_down_low_frac {-1.0f}
size_t g_filter_push_down_passing_row_ubound {0}
size_t g_gpu_smem_threshold
Initial value:
{
4096}

Definition at line 138 of file Execute.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions().

size_t g_hashtable_cache_total_bytes {size_t(1) << 32}

Definition at line 160 of file Execute.cpp.

Referenced by CommandLineOptions::parse_command_line().

bool g_inner_join_fragment_skipping {true}

Definition at line 94 of file Execute.cpp.

Referenced by Executor::createKernels(), and CommandLineOptions::fillOptions().

size_t g_max_cacheable_hashtable_size_bytes {size_t(1) << 31}

Definition at line 161 of file Execute.cpp.

Referenced by CommandLineOptions::parse_command_line().

size_t g_max_cacheable_query_resultset_size_bytes {size_t(1) << 31}
size_t g_max_memory_allocation_size {2000000000}
size_t g_min_memory_allocation_size
Initial value:
{
256}

Definition at line 125 of file Execute.cpp.

Referenced by create_dev_group_by_buffers(), and CommandLineOptions::fillDeveloperOptions().

bool g_null_div_by_zero {false}
size_t g_num_tuple_threshold_switch_to_baseline {100000}
bool g_optimize_cuda_block_and_grid_sizes {false}
bool g_optimize_row_initialization {true}
unsigned g_pending_query_interrupt_freq {1000}
size_t g_preflight_count_query_threshold {1000000}
size_t g_query_resultset_cache_total_bytes {size_t(1) << 32}
size_t g_ratio_num_hash_entry_to_num_tuple_switch_to_baseline {100}
double g_running_query_interrupt_freq {0.1}
bool g_strip_join_covered_quals {false}
size_t g_watchdog_max_projected_rows_per_device {128000000}
size_t g_watchdog_none_encoded_string_translation_limit {1000000UL}
std::unique_ptr<llvm::Module> udf_cpu_module
std::unique_ptr<llvm::Module> udf_gpu_module