OmniSciDB  21ac014ffc
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Execute.h File Reference
#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <cstddef>
#include <cstdlib>
#include <deque>
#include <functional>
#include <limits>
#include <map>
#include <mutex>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <llvm/IR/Function.h>
#include <llvm/IR/Value.h>
#include <llvm/Linker/Linker.h>
#include <llvm/Transforms/Utils/ValueMapper.h>
#include <rapidjson/document.h>
#include "QueryEngine/AggregatedColRange.h"
#include "QueryEngine/BufferCompaction.h"
#include "QueryEngine/CartesianProduct.h"
#include "QueryEngine/CgenState.h"
#include "QueryEngine/CodeCache.h"
#include "QueryEngine/CompilationOptions.h"
#include "QueryEngine/DateTimeUtils.h"
#include "QueryEngine/Descriptors/QueryCompilationDescriptor.h"
#include "QueryEngine/Descriptors/QueryFragmentDescriptor.h"
#include "QueryEngine/ExecutionKernel.h"
#include "QueryEngine/GpuSharedMemoryContext.h"
#include "QueryEngine/GroupByAndAggregate.h"
#include "QueryEngine/JoinHashTable/HashJoin.h"
#include "QueryEngine/LoopControlFlow/JoinLoop.h"
#include "QueryEngine/NvidiaKernel.h"
#include "QueryEngine/PlanState.h"
#include "QueryEngine/QueryPlanDagCache.h"
#include "QueryEngine/RelAlgExecutionUnit.h"
#include "QueryEngine/RelAlgTranslator.h"
#include "QueryEngine/StringDictionaryGenerations.h"
#include "QueryEngine/TableGenerations.h"
#include "QueryEngine/TargetMetaInfo.h"
#include "QueryEngine/WindowContext.h"
#include "DataMgr/Chunk/Chunk.h"
#include "Logger/Logger.h"
#include "Shared/SystemParameters.h"
#include "Shared/funcannotations.h"
#include "Shared/mapd_shared_mutex.h"
#include "Shared/measure.h"
#include "Shared/thread_count.h"
#include "Shared/toString.h"
#include "StringDictionary/LruCache.hpp"
#include "StringDictionary/StringDictionary.h"
#include "StringDictionary/StringDictionaryProxy.h"
#include "ThriftHandler/CommandLineOptions.h"
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  QuerySessionStatus
 
class  WatchdogException
 
class  CompilationRetryNoLazyFetch
 
class  CompilationRetryNewScanLimit
 
class  TooManyLiterals
 
class  CompilationRetryNoCompaction
 
class  QueryMustRunOnCpu
 
class  ParseIRError
 
class  StringConstInResultSet
 
struct  TableUpdateMetadata
 
class  UpdateLogForFragment
 
class  Executor
 
struct  Executor::JoinHashTableOrError
 
struct  Executor::GroupColLLVMValue
 
class  Executor::FetchCacheAnchor
 
struct  Executor::ExecutorMutexHolder
 

Typedefs

using QueryCompilationDescriptorOwned = std::unique_ptr< QueryCompilationDescriptor >
 
using QueryMemoryDescriptorOwned = std::unique_ptr< QueryMemoryDescriptor >
 
using QuerySessionId = std::string
 
using CurrentQueryStatus = std::pair< QuerySessionId, std::string >
 
using InterruptFlagMap = std::map< QuerySessionId, bool >
 
using QuerySessionMap = std::map< const QuerySessionId, std::map< std::string, QuerySessionStatus >>
 
using RowDataProvider = Fragmenter_Namespace::RowDataProvider
 
using ColumnToFragmentsMap = std::map< const ColumnDescriptor *, std::set< int32_t >>
 
using TableToFragmentIds = std::map< int32_t, std::set< int32_t >>
 
using LLVMValueVector = std::vector< llvm::Value * >
 

Functions

void read_rt_udf_gpu_module (const std::string &udf_ir)
 
void read_rt_udf_cpu_module (const std::string &udf_ir)
 
bool is_rt_udf_module_present (bool cpu_only=false)
 
llvm::Value * get_arg_by_name (llvm::Function *func, const std::string &name)
 
uint32_t log2_bytes (const uint32_t bytes)
 
const ColumnDescriptorget_column_descriptor (const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
 
const Analyzer::Exprextract_cast_arg (const Analyzer::Expr *expr)
 
std::string numeric_type_name (const SQLTypeInfo &ti)
 
const ColumnDescriptorget_column_descriptor_maybe (const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
 
const ResultSetPtrget_temporary_table (const TemporaryTables *temporary_tables, const int table_id)
 
const SQLTypeInfo get_column_type (const int col_id, const int table_id, const ColumnDescriptor *cd, const TemporaryTables *temporary_tables)
 
std::vector< Analyzer::Expr * > get_exprs_not_owned (const std::vector< std::shared_ptr< Analyzer::Expr >> &exprs)
 
std::ostream & operator<< (std::ostream &, FetchResult const &)
 
std::string get_null_check_suffix (const SQLTypeInfo &lhs_ti, const SQLTypeInfo &rhs_ti)
 
bool is_unnest (const Analyzer::Expr *expr)
 
bool is_constructed_point (const Analyzer::Expr *expr)
 
bool is_trivial_loop_join (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
 
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)
 
RUNTIME_EXPORT void register_buffer_with_executor_rsm (int64_t exec, int8_t *buffer)
 
const Analyzer::Exprremove_cast_to_int (const Analyzer::Expr *expr)
 

Typedef Documentation

using ColumnToFragmentsMap = std::map<const ColumnDescriptor*, std::set<int32_t>>

Definition at line 308 of file Execute.h.

using CurrentQueryStatus = std::pair<QuerySessionId, std::string>

Definition at line 81 of file Execute.h.

using InterruptFlagMap = std::map<QuerySessionId, bool>

Definition at line 82 of file Execute.h.

using LLVMValueVector = std::vector<llvm::Value*>

Definition at line 353 of file Execute.h.

Definition at line 77 of file Execute.h.

Definition at line 79 of file Execute.h.

using QuerySessionId = std::string

Definition at line 80 of file Execute.h.

using QuerySessionMap = std::map<const QuerySessionId, std::map<std::string, QuerySessionStatus>>

Definition at line 151 of file Execute.h.

using TableToFragmentIds = std::map<int32_t, std::set<int32_t>>

Definition at line 309 of file Execute.h.

Function Documentation

const Analyzer::Expr* extract_cast_arg ( const Analyzer::Expr expr)
inline

Definition at line 201 of file Execute.h.

References kCAST.

Referenced by CodeGenerator::codegen(), CodeGenerator::createInValuesBitmap(), and anonymous_namespace{ExpressionRewrite.cpp}::OrToInVisitor::visitBinOper().

201  {
202  const auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr);
203  if (!cast_expr || cast_expr->get_optype() != kCAST) {
204  return expr;
205  }
206  return cast_expr->get_operand();
207 }
Definition: sqldefs.h:49

+ Here is the caller graph for this function:

llvm::Value* get_arg_by_name ( llvm::Function *  func,
const std::string &  name 
)
inline

Definition at line 166 of file Execute.h.

References CHECK, and setup::name.

Referenced by GroupByAndAggregate::codegen(), TargetExprCodegen::codegenAggregate(), HashJoin::codegenHashTableLoad(), PerfectJoinHashTable::codegenHashTableLoad(), CodeGenerator::codegenHoistedConstantsLoads(), GroupByAndAggregate::codegenOutputSlot(), CodeGenerator::codegenRowId(), GroupByAndAggregate::getAdditionalLiteral(), and Executor::preloadFragOffsets().

166  {
167  for (auto& arg : func->args()) {
168  if (arg.getName() == name) {
169  return &arg;
170  }
171  }
172  CHECK(false);
173  return nullptr;
174 }
string name
Definition: setup.in.py:72
#define CHECK(condition)
Definition: Logger.h:206

+ Here is the caller graph for this function:

std::unordered_set<int> get_available_gpus ( const Catalog_Namespace::Catalog cat)
const ColumnDescriptor* get_column_descriptor ( const int  col_id,
const int  table_id,
const Catalog_Namespace::Catalog cat 
)
inline

Definition at line 191 of file Execute.h.

References CHECK, CHECK_GT, and Catalog_Namespace::Catalog::getMetadataForColumn().

Referenced by CodeGenerator::codegenColVar(), CodeGenerator::codegenGeoColumnVar(), RelAlgExecutor::executeSimpleInsert(), get_column_descriptor_maybe(), Executor::getColLazyFetchInfo(), ColumnFetcher::getOneTableColumnFragment(), spatial_type::NRings::getOperand(), spatial_type::NPoints::getOperand(), PlanState::isLazyFetchColumn(), RelAlgExecutor::isRowidLookup(), ColumnFetcher::linearizeColumnFragments(), and Executor::skipFragment().

194  {
195  CHECK_GT(table_id, 0);
196  const auto col_desc = cat.getMetadataForColumn(table_id, col_id);
197  CHECK(col_desc);
198  return col_desc;
199 }
#define CHECK_GT(x, y)
Definition: Logger.h:218
const ColumnDescriptor * getMetadataForColumn(int tableId, const std::string &colName) const
#define CHECK(condition)
Definition: Logger.h:206

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const ColumnDescriptor* get_column_descriptor_maybe ( const int  col_id,
const int  table_id,
const Catalog_Namespace::Catalog cat 
)
inline

Definition at line 220 of file Execute.h.

References CHECK, and get_column_descriptor().

Referenced by anonymous_namespace{GroupByAndAggregate.cpp}::expr_is_rowid(), PerfectJoinHashTable::fetchColumnsForDevice(), BaselineJoinHashTable::fetchColumnsForDevice(), OverlapsJoinHashTable::fetchColumnsForDevice(), Executor::getColumnDescriptor(), ColumnFetcher::getOneColumnFragment(), Executor::getPhysicalColumnDescriptor(), needs_dictionary_translation(), HashJoin::normalizeColumnPair(), anonymous_namespace{QueryMemoryDescriptor.cpp}::target_expr_proj_indices(), and anonymous_namespace{Execute.cpp}::try_get_column_descriptor().

223  {
224  CHECK(table_id);
225  return table_id > 0 ? get_column_descriptor(col_id, table_id, cat) : nullptr;
226 }
#define CHECK(condition)
Definition: Logger.h:206
const ColumnDescriptor * get_column_descriptor(const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
Definition: Execute.h:191

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const SQLTypeInfo get_column_type ( const int  col_id,
const int  table_id,
const ColumnDescriptor cd,
const TemporaryTables temporary_tables 
)
inline

Definition at line 236 of file Execute.h.

References CHECK, CHECK_EQ, ColumnDescriptor::columnId, ColumnDescriptor::columnType, get_temporary_table(), and ColumnDescriptor::tableId.

Referenced by ColumnFetcher::getOneTableColumnFragment(), needs_dictionary_translation(), and HashJoin::normalizeColumnPair().

239  {
240  CHECK(cd || temporary_tables);
241  if (cd) {
242  CHECK_EQ(col_id, cd->columnId);
243  CHECK_EQ(table_id, cd->tableId);
244  return cd->columnType;
245  }
246  const auto& temp = get_temporary_table(temporary_tables, table_id);
247  return temp->getColType(col_id);
248 }
#define CHECK_EQ(x, y)
Definition: Logger.h:214
const ResultSetPtr & get_temporary_table(const TemporaryTables *temporary_tables, const int table_id)
Definition: Execute.h:228
#define CHECK(condition)
Definition: Logger.h:206
SQLTypeInfo columnType

+ 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 1053 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl().

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

+ Here is the caller graph for this function:

std::vector<Analyzer::Expr*> get_exprs_not_owned ( const std::vector< std::shared_ptr< Analyzer::Expr >> &  exprs)
inline

Definition at line 251 of file Execute.h.

Referenced by RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createTableFunctionWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), and anonymous_namespace{RelAlgExecutor.cpp}::get_inputs_meta().

252  {
253  std::vector<Analyzer::Expr*> exprs_not_owned;
254  for (const auto& expr : exprs) {
255  exprs_not_owned.push_back(expr.get());
256  }
257  return exprs_not_owned;
258 }

+ Here is the caller graph for this function:

std::string get_null_check_suffix ( const SQLTypeInfo lhs_ti,
const SQLTypeInfo rhs_ti 
)
inline

Definition at line 1181 of file Execute.h.

References CHECK, and SQLTypeInfo::get_notnull().

Referenced by CodeGenerator::codegenCmp(), CodeGenerator::codegenDeciDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenIntArith(), and CodeGenerator::codegenStrCmp().

1182  {
1183  if (lhs_ti.get_notnull() && rhs_ti.get_notnull()) {
1184  return "";
1185  }
1186  std::string null_check_suffix{"_nullable"};
1187  if (lhs_ti.get_notnull()) {
1188  CHECK(!rhs_ti.get_notnull());
1189  null_check_suffix += "_rhs";
1190  } else if (rhs_ti.get_notnull()) {
1191  CHECK(!lhs_ti.get_notnull());
1192  null_check_suffix += "_lhs";
1193  }
1194  return null_check_suffix;
1195 }
#define CHECK(condition)
Definition: Logger.h:206
HOST DEVICE bool get_notnull() const
Definition: sqltypes.h:330

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const ResultSetPtr& get_temporary_table ( const TemporaryTables temporary_tables,
const int  table_id 
)
inline

Definition at line 228 of file Execute.h.

References CHECK, and CHECK_LT.

Referenced by anonymous_namespace{ExternalExecutor.cpp}::create_table_schema(), RelAlgExecutor::executeDelete(), RelAlgExecutor::executeProject(), RelAlgExecutor::executeUpdate(), get_column_type(), ColumnFetcher::getOneColumnFragment(), and ColumnFetcher::getResultSetColumn().

229  {
230  CHECK_LT(table_id, 0);
231  const auto it = temporary_tables->find(table_id);
232  CHECK(it != temporary_tables->end());
233  return it->second;
234 }
#define CHECK_LT(x, y)
Definition: Logger.h:216
#define CHECK(condition)
Definition: Logger.h:206

+ Here is the caller graph for this function:

bool is_constructed_point ( const Analyzer::Expr expr)
inline

Definition at line 1202 of file Execute.h.

References Analyzer::UOper::get_operand(), and kCAST.

Referenced by anonymous_namespace{FromTableReordering.cpp}::get_join_qual_cost(), CodeGenerator::hashJoinLhs(), HashJoin::normalizeColumnPair(), and rewrite_overlaps_conjunction().

1202  {
1203  auto uoper = dynamic_cast<const Analyzer::UOper*>(expr);
1204  auto oper = (uoper && uoper->get_optype() == kCAST) ? uoper->get_operand() : expr;
1205  auto arr = dynamic_cast<const Analyzer::ArrayExpr*>(oper);
1206  return (arr && arr->isLocalAlloc() && arr->get_type_info().is_fixlen_array());
1207 }
Definition: sqldefs.h:49
const Expr * get_operand() const
Definition: Analyzer.h:371

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool is_rt_udf_module_present ( bool  cpu_only = false)

Definition at line 1733 of file NativeCodegen.cpp.

1733  {
1734  return (cpu_only || rt_udf_gpu_module != nullptr) && (rt_udf_cpu_module != nullptr);
1735 }
std::unique_ptr< llvm::Module > rt_udf_cpu_module
std::unique_ptr< llvm::Module > rt_udf_gpu_module
bool is_trivial_loop_join ( const std::vector< InputTableInfo > &  query_infos,
const RelAlgExecutionUnit ra_exe_unit 
)

Definition at line 1161 of file Execute.cpp.

References CHECK, g_trivial_loop_join_threshold, i, and RelAlgExecutionUnit::input_descs.

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

1162  {
1163  if (ra_exe_unit.input_descs.size() < 2) {
1164  return false;
1165  }
1166 
1167  // We only support loop join at the end of folded joins
1168  // where ra_exe_unit.input_descs.size() > 2 for now.
1169  const auto inner_table_id = ra_exe_unit.input_descs.back().getTableId();
1170 
1171  std::optional<size_t> inner_table_idx;
1172  for (size_t i = 0; i < query_infos.size(); ++i) {
1173  if (query_infos[i].table_id == inner_table_id) {
1174  inner_table_idx = i;
1175  break;
1176  }
1177  }
1178  CHECK(inner_table_idx);
1179  return query_infos[*inner_table_idx].info.getNumTuples() <=
1181 }
std::vector< InputDescriptor > input_descs
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:82
#define CHECK(condition)
Definition: Logger.h:206

+ Here is the caller graph for this function:

bool is_unnest ( const Analyzer::Expr expr)
inline

Definition at line 1197 of file Execute.h.

References Analyzer::UOper::get_optype(), and kUNNEST.

Referenced by CodeGenerator::codegen(), and CodeGenerator::codegenCmp().

1197  {
1198  return dynamic_cast<const Analyzer::UOper*>(expr) &&
1199  static_cast<const Analyzer::UOper*>(expr)->get_optype() == kUNNEST;
1200 }
SQLOps get_optype() const
Definition: Analyzer.h:370

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

uint32_t log2_bytes ( const uint32_t  bytes)
inline

Definition at line 176 of file Execute.h.

Referenced by CodeGenerator::codegen(), GroupByAndAggregate::codegenAggArg(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenGeoArgs(), CodeGenerator::codegenGeoFunctionOperator(), spatial_type::StartEndPoint::codegenLoads(), spatial_type::NPoints::codegenLoads(), spatial_type::PointN::codegenLoads(), spatial_type::NRings::codegenLoads(), and Executor::groupByColumnCodegen().

176  {
177  switch (bytes) {
178  case 1:
179  return 0;
180  case 2:
181  return 1;
182  case 4:
183  return 2;
184  case 8:
185  return 3;
186  default:
187  abort();
188  }
189 }

+ Here is the caller graph for this function:

std::string numeric_type_name ( const SQLTypeInfo ti)
inline

Definition at line 209 of file Execute.h.

References CHECK, SQLTypeInfo::get_compression(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_type(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timeinterval(), kDOUBLE, kENCODING_DICT, and to_string().

Referenced by TargetExprCodegen::codegenAggregate(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenQualifierCmp(), CodeGenerator::codegenUMinus(), CodeGenerator::codgenAdjustFixedEncNull(), Executor::groupByColumnCodegen(), and anonymous_namespace{ArithmeticIR.cpp}::numeric_or_time_interval_type_name().

209  {
210  CHECK(ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
211  ti.is_fp() || (ti.is_string() && ti.get_compression() == kENCODING_DICT) ||
212  ti.is_timeinterval());
213  if (ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
214  ti.is_string() || ti.is_timeinterval()) {
215  return "int" + std::to_string(ti.get_logical_size() * 8) + "_t";
216  }
217  return ti.get_type() == kDOUBLE ? "double" : "float";
218 }
bool is_fp() const
Definition: sqltypes.h:502
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:323
bool is_time() const
Definition: sqltypes.h:504
std::string to_string(char const *&&v)
int get_logical_size() const
Definition: sqltypes.h:334
bool is_integer() const
Definition: sqltypes.h:500
bool is_timeinterval() const
Definition: sqltypes.h:509
bool is_boolean() const
Definition: sqltypes.h:505
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:331
#define CHECK(condition)
Definition: Logger.h:206
bool is_string() const
Definition: sqltypes.h:498
bool is_decimal() const
Definition: sqltypes.h:501

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 2474 of file Execute.cpp.

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

2474  {
2475  return os << "col_buffers" << shared::printContainer(fetch_result.col_buffers)
2476  << " num_rows" << shared::printContainer(fetch_result.num_rows)
2477  << " frag_offsets" << shared::printContainer(fetch_result.frag_offsets);
2478 }
PrintContainer< CONTAINER > printContainer(CONTAINER &container)
Definition: misc.h:96

+ Here is the call graph for this function:

void read_rt_udf_cpu_module ( const std::string &  udf_ir)

Definition at line 1803 of file NativeCodegen.cpp.

Referenced by DBHandler::register_runtime_extension_functions().

1803  {
1804  llvm::SMDiagnostic parse_error;
1805 
1806  auto buf =
1807  std::make_unique<llvm::MemoryBufferRef>(udf_ir_string, "Runtime UDF for CPU");
1808 
1809  rt_udf_cpu_module = llvm::parseIR(*buf, parse_error, getGlobalLLVMContext());
1810  if (!rt_udf_cpu_module) {
1811  LOG(IR) << "read_rt_udf_cpu_module:LLVM IR:\n" << udf_ir_string << "\nEnd of LLVM IR";
1812  throw_parseIR_error(parse_error);
1813  }
1814 }
std::unique_ptr< llvm::Module > rt_udf_cpu_module
#define LOG(tag)
Definition: Logger.h:200
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)
llvm::LLVMContext & getGlobalLLVMContext()

+ Here is the caller graph for this function:

void read_rt_udf_gpu_module ( const std::string &  udf_ir)

Definition at line 1780 of file NativeCodegen.cpp.

References CHECK, CHECK_GT, CHECK_LE, g_running_query_interrupt_freq, and shared::getExpOfTwo().

Referenced by DBHandler::register_runtime_extension_functions().

1780  {
1781  llvm::SMDiagnostic parse_error;
1782 
1783  auto buf =
1784  std::make_unique<llvm::MemoryBufferRef>(udf_ir_string, "Runtime UDF for GPU");
1785 
1786  rt_udf_gpu_module = llvm::parseIR(*buf, parse_error, getGlobalLLVMContext());
1787  if (!rt_udf_gpu_module) {
1788  LOG(IR) << "read_rt_udf_gpu_module:NVVM IR:\n" << udf_ir_string << "\nEnd of NNVM IR";
1789  throw_parseIR_error(parse_error, "", /* is_gpu= */ true);
1790  }
1791 
1792  llvm::Triple gpu_triple(rt_udf_gpu_module->getTargetTriple());
1793  if (!gpu_triple.isNVPTX()) {
1794  LOG(IR) << "read_rt_udf_gpu_module:NVVM IR:\n" << udf_ir_string << "\nEnd of NNVM IR";
1795  LOG(WARNING) << "Expected triple nvptx64-nvidia-cuda for NVVM IR but got "
1796  << gpu_triple.str()
1797  << ". Executing runtime UDFs on GPU will be disabled.";
1798  rt_udf_gpu_module = nullptr;
1799  return;
1800  }
1801 }
#define LOG(tag)
Definition: Logger.h:200
std::unique_ptr< llvm::Module > rt_udf_gpu_module
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)
llvm::LLVMContext & getGlobalLLVMContext()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

RUNTIME_EXPORT void register_buffer_with_executor_rsm ( int64_t  exec,
int8_t *  buffer 
)

Definition at line 227 of file ExtensionsIR.cpp.

228  {
229  Executor* exec_ptr = reinterpret_cast<Executor*>(exec);
230  if (buffer != nullptr) {
231  exec_ptr->getRowSetMemoryOwner()->addVarlenBuffer(buffer);
232  }
233 }
const Analyzer::Expr* remove_cast_to_int ( const Analyzer::Expr expr)

Definition at line 537 of file ColumnIR.cpp.

References Analyzer::Expr::get_type_info(), and kCAST.

Referenced by anonymous_namespace{DateTimePlusRewrite.cpp}::get_dt_field(), and CodeGenerator::hashJoinLhs().

537  {
538  const auto uoper = dynamic_cast<const Analyzer::UOper*>(expr);
539  if (!uoper || uoper->get_optype() != kCAST) {
540  return nullptr;
541  }
542  const auto& target_ti = uoper->get_type_info();
543  if (!target_ti.is_integer()) {
544  return nullptr;
545  }
546  return uoper->get_operand();
547 }
Definition: sqldefs.h:49
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:78

+ Here is the call graph for this function:

+ Here is the caller graph for this function: