OmniSciDB  6686921089
 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 325 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 370 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 149 of file Execute.h.

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

Definition at line 326 of file Execute.h.

Function Documentation

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

Definition at line 199 of file Execute.h.

References kCAST.

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

199  {
200  const auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr);
201  if (!cast_expr || cast_expr->get_optype() != kCAST) {
202  return expr;
203  }
204  return cast_expr->get_operand();
205 }
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 164 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().

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

+ 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 189 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().

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

+ 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 218 of file Execute.h.

References CHECK, and get_column_descriptor().

Referenced by anonymous_namespace{GroupByAndAggregate.cpp}::expr_is_rowid(), OverlapsJoinHashTable::fetchColumnsForDevice(), PerfectJoinHashTable::fetchColumnsForDevice(), BaselineJoinHashTable::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().

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

+ 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 234 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().

237  {
238  CHECK(cd || temporary_tables);
239  if (cd) {
240  CHECK_EQ(col_id, cd->columnId);
241  CHECK_EQ(table_id, cd->tableId);
242  return cd->columnType;
243  }
244  const auto& temp = get_temporary_table(temporary_tables, table_id);
245  return temp->getColType(col_id);
246 }
#define CHECK_EQ(x, y)
Definition: Logger.h:217
const ResultSetPtr & get_temporary_table(const TemporaryTables *temporary_tables, const int table_id)
Definition: Execute.h:226
#define CHECK(condition)
Definition: Logger.h:209
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 1074 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl().

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

+ 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 249 of file Execute.h.

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

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

+ 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 1205 of file Execute.h.

References CHECK, and SQLTypeInfo::get_notnull().

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

1206  {
1207  if (lhs_ti.get_notnull() && rhs_ti.get_notnull()) {
1208  return "";
1209  }
1210  std::string null_check_suffix{"_nullable"};
1211  if (lhs_ti.get_notnull()) {
1212  CHECK(!rhs_ti.get_notnull());
1213  null_check_suffix += "_rhs";
1214  } else if (rhs_ti.get_notnull()) {
1215  CHECK(!lhs_ti.get_notnull());
1216  null_check_suffix += "_lhs";
1217  }
1218  return null_check_suffix;
1219 }
#define CHECK(condition)
Definition: Logger.h:209
HOST DEVICE bool get_notnull() const
Definition: sqltypes.h:336

+ 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 226 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().

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

+ Here is the caller graph for this function:

bool is_constructed_point ( const Analyzer::Expr expr)
inline

Definition at line 1226 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().

1226  {
1227  auto uoper = dynamic_cast<const Analyzer::UOper*>(expr);
1228  auto oper = (uoper && uoper->get_optype() == kCAST) ? uoper->get_operand() : expr;
1229  auto arr = dynamic_cast<const Analyzer::ArrayExpr*>(oper);
1230  return (arr && arr->isLocalAlloc() && arr->get_type_info().is_fixlen_array());
1231 }
Definition: sqldefs.h:49
const Expr * get_operand() const
Definition: Analyzer.h:370

+ 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 1769 of file NativeCodegen.cpp.

1769  {
1770  return (cpu_only || rt_udf_gpu_module != nullptr) && (rt_udf_cpu_module != nullptr);
1771 }
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 1182 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().

1183  {
1184  if (ra_exe_unit.input_descs.size() < 2) {
1185  return false;
1186  }
1187 
1188  // We only support loop join at the end of folded joins
1189  // where ra_exe_unit.input_descs.size() > 2 for now.
1190  const auto inner_table_id = ra_exe_unit.input_descs.back().getTableId();
1191 
1192  std::optional<size_t> inner_table_idx;
1193  for (size_t i = 0; i < query_infos.size(); ++i) {
1194  if (query_infos[i].table_id == inner_table_id) {
1195  inner_table_idx = i;
1196  break;
1197  }
1198  }
1199  CHECK(inner_table_idx);
1200  return query_infos[*inner_table_idx].info.getNumTuples() <=
1202 }
std::vector< InputDescriptor > input_descs
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:85
#define CHECK(condition)
Definition: Logger.h:209

+ Here is the caller graph for this function:

bool is_unnest ( const Analyzer::Expr expr)
inline

Definition at line 1221 of file Execute.h.

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

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

1221  {
1222  return dynamic_cast<const Analyzer::UOper*>(expr) &&
1223  static_cast<const Analyzer::UOper*>(expr)->get_optype() == kUNNEST;
1224 }
SQLOps get_optype() const
Definition: Analyzer.h:369

+ 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 174 of file Execute.h.

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

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

+ Here is the caller graph for this function:

std::string numeric_type_name ( const SQLTypeInfo ti)
inline

Definition at line 207 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().

207  {
208  CHECK(ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
209  ti.is_fp() || (ti.is_string() && ti.get_compression() == kENCODING_DICT) ||
210  ti.is_timeinterval());
211  if (ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
212  ti.is_string() || ti.is_timeinterval()) {
213  return "int" + std::to_string(ti.get_logical_size() * 8) + "_t";
214  }
215  return ti.get_type() == kDOUBLE ? "double" : "float";
216 }
bool is_fp() const
Definition: sqltypes.h:513
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:329
bool is_time() const
Definition: sqltypes.h:515
std::string to_string(char const *&&v)
int get_logical_size() const
Definition: sqltypes.h:340
bool is_integer() const
Definition: sqltypes.h:511
bool is_timeinterval() const
Definition: sqltypes.h:520
bool is_boolean() const
Definition: sqltypes.h:516
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:337
#define CHECK(condition)
Definition: Logger.h:209
bool is_string() const
Definition: sqltypes.h:509
bool is_decimal() const
Definition: sqltypes.h:512

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

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

2514  {
2515  return os << "col_buffers" << shared::printContainer(fetch_result.col_buffers)
2516  << " num_rows" << shared::printContainer(fetch_result.num_rows)
2517  << " frag_offsets" << shared::printContainer(fetch_result.frag_offsets);
2518 }
PrintContainer< CONTAINER > printContainer(CONTAINER &container)
Definition: misc.h:105

+ Here is the call graph for this function:

void read_rt_udf_cpu_module ( const std::string &  udf_ir)

Definition at line 1839 of file NativeCodegen.cpp.

Referenced by DBHandler::register_runtime_extension_functions().

1839  {
1840  llvm::SMDiagnostic parse_error;
1841 
1842  auto buf =
1843  std::make_unique<llvm::MemoryBufferRef>(udf_ir_string, "Runtime UDF for CPU");
1844 
1845  rt_udf_cpu_module = llvm::parseIR(*buf, parse_error, getGlobalLLVMContext());
1846  if (!rt_udf_cpu_module) {
1847  LOG(IR) << "read_rt_udf_cpu_module:LLVM IR:\n" << udf_ir_string << "\nEnd of LLVM IR";
1848  throw_parseIR_error(parse_error);
1849  }
1850 }
std::unique_ptr< llvm::Module > rt_udf_cpu_module
#define LOG(tag)
Definition: Logger.h:203
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 1816 of file NativeCodegen.cpp.

Referenced by DBHandler::register_runtime_extension_functions().

1816  {
1817  llvm::SMDiagnostic parse_error;
1818 
1819  auto buf =
1820  std::make_unique<llvm::MemoryBufferRef>(udf_ir_string, "Runtime UDF for GPU");
1821 
1822  rt_udf_gpu_module = llvm::parseIR(*buf, parse_error, getGlobalLLVMContext());
1823  if (!rt_udf_gpu_module) {
1824  LOG(IR) << "read_rt_udf_gpu_module:NVVM IR:\n" << udf_ir_string << "\nEnd of NNVM IR";
1825  throw_parseIR_error(parse_error, "", /* is_gpu= */ true);
1826  }
1827 
1828  llvm::Triple gpu_triple(rt_udf_gpu_module->getTargetTriple());
1829  if (!gpu_triple.isNVPTX()) {
1830  LOG(IR) << "read_rt_udf_gpu_module:NVVM IR:\n" << udf_ir_string << "\nEnd of NNVM IR";
1831  LOG(WARNING) << "Expected triple nvptx64-nvidia-cuda for NVVM IR but got "
1832  << gpu_triple.str()
1833  << ". Executing runtime UDFs on GPU will be disabled.";
1834  rt_udf_gpu_module = nullptr;
1835  return;
1836  }
1837 }
#define LOG(tag)
Definition: Logger.h:203
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 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:77

+ Here is the call graph for this function:

+ Here is the caller graph for this function: