OmniSciDB  5ade3759e0
anonymous_namespace{NativeCodegen.cpp} Namespace Reference

Functions

void eliminate_dead_self_recursive_funcs (llvm::Module &M, const std::unordered_set< llvm::Function *> &live_funcs)
 
void optimize_ir (llvm::Function *query_func, llvm::Module *module, const std::unordered_set< llvm::Function *> &live_funcs, const CompilationOptions &co)
 
std::string cpp_to_llvm_name (const std::string &s)
 
std::string gen_array_any_all_sigs ()
 
std::string gen_translate_null_key_sigs ()
 
void link_udf_module (const std::unique_ptr< llvm::Module > &udf_module, llvm::Module &module, CgenState *cgen_state, llvm::Linker::Flags flags=llvm::Linker::Flags::None)
 
void bind_pos_placeholders (const std::string &pos_fn_name, const bool use_resume_param, llvm::Function *query_func, llvm::Module *module)
 
std::vector< llvm::Value * > generate_column_heads_load (const int num_columns, llvm::Function *query_func, llvm::LLVMContext &context)
 
void set_row_func_argnames (llvm::Function *row_func, const size_t in_col_count, const size_t agg_col_count, const bool hoist_literals)
 
std::pair< llvm::Function *, std::vector< llvm::Value * > > create_row_function (const size_t in_col_count, const size_t agg_col_count, const bool hoist_literals, llvm::Function *query_func, llvm::Module *module, llvm::LLVMContext &context)
 
void bind_query (llvm::Function *query_func, const std::string &query_fname, llvm::Function *multifrag_query_func, llvm::Module *module)
 
std::vector< std::string > get_agg_fnames (const std::vector< Analyzer::Expr *> &target_exprs, const bool is_group_by)
 
template<typename InstType >
llvm::Value * find_variable_in_basic_block (llvm::Function *func, std::string bb_name, std::string variable_name)
 
bool always_clone_runtime_function (const llvm::Function *func)
 

Variables

const std::string cuda_rt_decls
 

Function Documentation

◆ always_clone_runtime_function()

bool anonymous_namespace{NativeCodegen.cpp}::always_clone_runtime_function ( const llvm::Function *  func)

Definition at line 1546 of file NativeCodegen.cpp.

Referenced by Executor::compileWorkUnit().

1546  {
1547  return func->getName() == "query_stub_hoisted_literals" ||
1548  func->getName() == "multifrag_query_hoisted_literals" ||
1549  func->getName() == "query_stub" || func->getName() == "multifrag_query" ||
1550  func->getName() == "fixed_width_int_decode" ||
1551  func->getName() == "fixed_width_unsigned_decode" ||
1552  func->getName() == "diff_fixed_width_int_decode" ||
1553  func->getName() == "fixed_width_double_decode" ||
1554  func->getName() == "fixed_width_float_decode" ||
1555  func->getName() == "fixed_width_small_date_decode" ||
1556  func->getName() == "record_error_code";
1557 }
+ Here is the caller graph for this function:

◆ bind_pos_placeholders()

void anonymous_namespace{NativeCodegen.cpp}::bind_pos_placeholders ( const std::string &  pos_fn_name,
const bool  use_resume_param,
llvm::Function *  query_func,
llvm::Module *  module 
)

Definition at line 906 of file NativeCodegen.cpp.

References get_arg_by_name().

Referenced by Executor::compileWorkUnit().

909  {
910  for (auto it = llvm::inst_begin(query_func), e = llvm::inst_end(query_func); it != e;
911  ++it) {
912  if (!llvm::isa<llvm::CallInst>(*it)) {
913  continue;
914  }
915  auto& pos_call = llvm::cast<llvm::CallInst>(*it);
916  if (std::string(pos_call.getCalledFunction()->getName()) == pos_fn_name) {
917  if (use_resume_param) {
918  const auto error_code_arg = get_arg_by_name(query_func, "error_code");
919  llvm::ReplaceInstWithInst(
920  &pos_call,
921  llvm::CallInst::Create(module->getFunction(pos_fn_name + "_impl"),
922  error_code_arg));
923  } else {
924  llvm::ReplaceInstWithInst(
925  &pos_call,
926  llvm::CallInst::Create(module->getFunction(pos_fn_name + "_impl")));
927  }
928  break;
929  }
930  }
931 }
llvm::Value * get_arg_by_name(llvm::Function *func, const std::string &name)
Definition: Execute.h:114
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ bind_query()

void anonymous_namespace{NativeCodegen.cpp}::bind_query ( llvm::Function *  query_func,
const std::string &  query_fname,
llvm::Function *  multifrag_query_func,
llvm::Module *  module 
)

Definition at line 1069 of file NativeCodegen.cpp.

References run-benchmark-import::args.

Referenced by Executor::compileWorkUnit().

1072  {
1073  std::vector<llvm::CallInst*> query_stubs;
1074  for (auto it = llvm::inst_begin(multifrag_query_func),
1075  e = llvm::inst_end(multifrag_query_func);
1076  it != e;
1077  ++it) {
1078  if (!llvm::isa<llvm::CallInst>(*it)) {
1079  continue;
1080  }
1081  auto& query_call = llvm::cast<llvm::CallInst>(*it);
1082  if (std::string(query_call.getCalledFunction()->getName()) == query_fname) {
1083  query_stubs.push_back(&query_call);
1084  }
1085  }
1086  for (auto& S : query_stubs) {
1087  std::vector<llvm::Value*> args;
1088  for (size_t i = 0; i < S->getNumArgOperands(); ++i) {
1089  args.push_back(S->getArgOperand(i));
1090  }
1091  llvm::ReplaceInstWithInst(S, llvm::CallInst::Create(query_func, args, ""));
1092  }
1093 }
+ Here is the caller graph for this function:

◆ cpp_to_llvm_name()

std::string anonymous_namespace{NativeCodegen.cpp}::cpp_to_llvm_name ( const std::string &  s)

Definition at line 288 of file NativeCodegen.cpp.

References CHECK.

Referenced by gen_array_any_all_sigs(), and gen_translate_null_key_sigs().

288  {
289  if (s == "int8_t") {
290  return "i8";
291  }
292  if (s == "int16_t") {
293  return "i16";
294  }
295  if (s == "int32_t") {
296  return "i32";
297  }
298  if (s == "int64_t") {
299  return "i64";
300  }
301  CHECK(s == "float" || s == "double");
302  return s;
303 }
#define CHECK(condition)
Definition: Logger.h:187
+ Here is the caller graph for this function:

◆ create_row_function()

std::pair<llvm::Function*, std::vector<llvm::Value*> > anonymous_namespace{NativeCodegen.cpp}::create_row_function ( const size_t  in_col_count,
const size_t  agg_col_count,
const bool  hoist_literals,
llvm::Function *  query_func,
llvm::Module *  module,
llvm::LLVMContext &  context 
)

Definition at line 999 of file NativeCodegen.cpp.

References agg_col_count, CHECK_EQ, generate_column_heads_load(), get_int_type(), and set_row_func_argnames().

Referenced by Executor::compileWorkUnit().

1005  {
1006  std::vector<llvm::Type*> row_process_arg_types;
1007 
1008  if (agg_col_count) {
1009  // output (aggregate) arguments
1010  for (size_t i = 0; i < agg_col_count; ++i) {
1011  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1012  }
1013  } else {
1014  // group by buffer
1015  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1016  // current match count
1017  row_process_arg_types.push_back(llvm::Type::getInt32PtrTy(context));
1018  // total match count passed from the caller
1019  row_process_arg_types.push_back(llvm::Type::getInt32PtrTy(context));
1020  // old total match count returned to the caller
1021  row_process_arg_types.push_back(llvm::Type::getInt32PtrTy(context));
1022  // max matched (total number of slots in the output buffer)
1023  row_process_arg_types.push_back(llvm::Type::getInt32PtrTy(context));
1024  }
1025 
1026  // aggregate init values
1027  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1028 
1029  // position argument
1030  row_process_arg_types.push_back(llvm::Type::getInt64Ty(context));
1031 
1032  // fragment row offset argument
1033  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1034 
1035  // number of rows for each scan
1036  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1037 
1038  // literals buffer argument
1039  if (hoist_literals) {
1040  row_process_arg_types.push_back(llvm::Type::getInt8PtrTy(context));
1041  }
1042 
1043  // Generate the function signature and column head fetches s.t.
1044  // double indirection isn't needed in the inner loop
1045  auto col_heads = generate_column_heads_load(in_col_count, query_func, context);
1046  CHECK_EQ(in_col_count, col_heads.size());
1047 
1048  // column buffer arguments
1049  for (size_t i = 0; i < in_col_count; ++i) {
1050  row_process_arg_types.emplace_back(llvm::Type::getInt8PtrTy(context));
1051  }
1052 
1053  // join hash table argument
1054  row_process_arg_types.push_back(llvm::Type::getInt64PtrTy(context));
1055 
1056  // generate the function
1057  auto ft =
1058  llvm::FunctionType::get(get_int_type(32, context), row_process_arg_types, false);
1059 
1060  auto row_func =
1061  llvm::Function::Create(ft, llvm::Function::ExternalLinkage, "row_func", module);
1062 
1063  // set the row function argument names; for debugging purposes only
1064  set_row_func_argnames(row_func, in_col_count, agg_col_count, hoist_literals);
1065 
1066  return std::make_pair(row_func, col_heads);
1067 }
#define CHECK_EQ(x, y)
Definition: Logger.h:195
const int64_t const uint32_t const uint32_t const uint32_t agg_col_count
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
std::vector< llvm::Value * > generate_column_heads_load(const int num_columns, llvm::Function *query_func, llvm::LLVMContext &context)
void set_row_func_argnames(llvm::Function *row_func, const size_t in_col_count, const size_t agg_col_count, const bool hoist_literals)
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ eliminate_dead_self_recursive_funcs()

void anonymous_namespace{NativeCodegen.cpp}::eliminate_dead_self_recursive_funcs ( llvm::Module &  M,
const std::unordered_set< llvm::Function *> &  live_funcs 
)

Definition at line 74 of file NativeCodegen.cpp.

Referenced by optimize_ir().

76  {
77  std::vector<llvm::Function*> dead_funcs;
78  for (auto& F : M) {
79  bool bAlive = false;
80  if (live_funcs.count(&F)) {
81  continue;
82  }
83  for (auto U : F.users()) {
84  auto* C = llvm::dyn_cast<const llvm::CallInst>(U);
85  if (!C || C->getParent()->getParent() != &F) {
86  bAlive = true;
87  break;
88  }
89  }
90  if (!bAlive) {
91  dead_funcs.push_back(&F);
92  }
93  }
94  for (auto pFn : dead_funcs) {
95  pFn->eraseFromParent();
96  }
97 }
+ Here is the caller graph for this function:

◆ find_variable_in_basic_block()

template<typename InstType >
llvm::Value* anonymous_namespace{NativeCodegen.cpp}::find_variable_in_basic_block ( llvm::Function *  func,
std::string  bb_name,
std::string  variable_name 
)

Definition at line 1292 of file NativeCodegen.cpp.

References run-benchmark-import::result.

1294  {
1295  llvm::Value* result = nullptr;
1296  if (func == nullptr || variable_name.empty()) {
1297  return result;
1298  }
1299  bool is_found = false;
1300  for (auto bb_it = func->begin(); bb_it != func->end() && !is_found; ++bb_it) {
1301  if (!bb_name.empty() && bb_it->getName() != bb_name) {
1302  continue;
1303  }
1304  for (auto inst_it = bb_it->begin(); inst_it != bb_it->end(); inst_it++) {
1305  if (llvm::isa<InstType>(*inst_it)) {
1306  if (inst_it->getName() == variable_name) {
1307  result = &*inst_it;
1308  is_found = true;
1309  break;
1310  }
1311  }
1312  }
1313  }
1314  return result;
1315 }

◆ gen_array_any_all_sigs()

std::string anonymous_namespace{NativeCodegen.cpp}::gen_array_any_all_sigs ( )

Definition at line 305 of file NativeCodegen.cpp.

References cpp_to_llvm_name(), and run-benchmark-import::result.

305  {
306  std::string result;
307  for (const std::string any_or_all : {"any", "all"}) {
308  for (const std::string elem_type :
309  {"int8_t", "int16_t", "int32_t", "int64_t", "float", "double"}) {
310  for (const std::string needle_type :
311  {"int8_t", "int16_t", "int32_t", "int64_t", "float", "double"}) {
312  for (const std::string op_name : {"eq", "ne", "lt", "le", "gt", "ge"}) {
313  result += ("declare i1 @array_" + any_or_all + "_" + op_name + "_" + elem_type +
314  "_" + needle_type + "(i8*, i64, " + cpp_to_llvm_name(needle_type) +
315  ", " + cpp_to_llvm_name(elem_type) + ");\n");
316  }
317  }
318  }
319  }
320  return result;
321 }
std::string cpp_to_llvm_name(const std::string &s)
+ Here is the call graph for this function:

◆ gen_translate_null_key_sigs()

std::string anonymous_namespace{NativeCodegen.cpp}::gen_translate_null_key_sigs ( )

Definition at line 323 of file NativeCodegen.cpp.

References cpp_to_llvm_name(), and run-benchmark-import::result.

323  {
324  std::string result;
325  for (const std::string key_type : {"int8_t", "int16_t", "int32_t", "int64_t"}) {
326  const auto key_llvm_type = cpp_to_llvm_name(key_type);
327  result += "declare i64 @translate_null_key_" + key_type + "(" + key_llvm_type + ", " +
328  key_llvm_type + ", i64);\n";
329  }
330  return result;
331 }
std::string cpp_to_llvm_name(const std::string &s)
+ Here is the call graph for this function:

◆ generate_column_heads_load()

std::vector<llvm::Value*> anonymous_namespace{NativeCodegen.cpp}::generate_column_heads_load ( const int  num_columns,
llvm::Function *  query_func,
llvm::LLVMContext &  context 
)

Definition at line 933 of file NativeCodegen.cpp.

Referenced by create_row_function().

935  {
936  auto max_col_local_id = num_columns - 1;
937  auto& fetch_bb = query_func->front();
938  llvm::IRBuilder<> fetch_ir_builder(&fetch_bb);
939  fetch_ir_builder.SetInsertPoint(&*fetch_bb.begin());
940  auto& byte_stream_arg = *query_func->args().begin();
941  std::vector<llvm::Value*> col_heads;
942  for (int col_id = 0; col_id <= max_col_local_id; ++col_id) {
943  col_heads.emplace_back(fetch_ir_builder.CreateLoad(fetch_ir_builder.CreateGEP(
944  &byte_stream_arg,
945  llvm::ConstantInt::get(llvm::Type::getInt32Ty(context), col_id))));
946  }
947  return col_heads;
948 }
+ Here is the caller graph for this function:

◆ get_agg_fnames()

std::vector<std::string> anonymous_namespace{NativeCodegen.cpp}::get_agg_fnames ( const std::vector< Analyzer::Expr *> &  target_exprs,
const bool  is_group_by 
)

Definition at line 1095 of file NativeCodegen.cpp.

References CHECK, g_rt_module(), Analyzer::AggExpr::get_aggtype(), getGlobalLLVMContext(), kAPPROX_COUNT_DISTINCT, kAVG, kCOUNT, kENCODING_NONE, kMAX, kMIN, kSAMPLE, kSUM, read_template_module(), and run-benchmark-import::result.

Referenced by Executor::compileWorkUnit().

1096  {
1097  std::vector<std::string> result;
1098  for (size_t target_idx = 0, agg_col_idx = 0; target_idx < target_exprs.size();
1099  ++target_idx, ++agg_col_idx) {
1100  const auto target_expr = target_exprs[target_idx];
1101  CHECK(target_expr);
1102  const auto target_type_info = target_expr->get_type_info();
1103  const auto agg_expr = dynamic_cast<Analyzer::AggExpr*>(target_expr);
1104  const bool is_varlen =
1105  (target_type_info.is_string() &&
1106  target_type_info.get_compression() == kENCODING_NONE) ||
1107  target_type_info.is_array(); // TODO: should it use is_varlen_array() ?
1108  if (!agg_expr || agg_expr->get_aggtype() == kSAMPLE) {
1109  result.emplace_back(target_type_info.is_fp() ? "agg_id_double" : "agg_id");
1110  if (is_varlen) {
1111  result.emplace_back("agg_id");
1112  }
1113  if (target_type_info.is_geometry()) {
1114  result.emplace_back("agg_id");
1115  for (auto i = 2; i < 2 * target_type_info.get_physical_coord_cols(); ++i) {
1116  result.emplace_back("agg_id");
1117  }
1118  }
1119  continue;
1120  }
1121  const auto agg_type = agg_expr->get_aggtype();
1122  const auto& agg_type_info =
1123  agg_type != kCOUNT ? agg_expr->get_arg()->get_type_info() : target_type_info;
1124  switch (agg_type) {
1125  case kAVG: {
1126  if (!agg_type_info.is_integer() && !agg_type_info.is_decimal() &&
1127  !agg_type_info.is_fp()) {
1128  throw std::runtime_error("AVG is only valid on integer and floating point");
1129  }
1130  result.emplace_back((agg_type_info.is_integer() || agg_type_info.is_time())
1131  ? "agg_sum"
1132  : "agg_sum_double");
1133  result.emplace_back((agg_type_info.is_integer() || agg_type_info.is_time())
1134  ? "agg_count"
1135  : "agg_count_double");
1136  break;
1137  }
1138  case kMIN: {
1139  if (agg_type_info.is_string() || agg_type_info.is_array() ||
1140  agg_type_info.is_geometry()) {
1141  throw std::runtime_error(
1142  "MIN on strings, arrays or geospatial types not supported yet");
1143  }
1144  result.emplace_back((agg_type_info.is_integer() || agg_type_info.is_time())
1145  ? "agg_min"
1146  : "agg_min_double");
1147  break;
1148  }
1149  case kMAX: {
1150  if (agg_type_info.is_string() || agg_type_info.is_array() ||
1151  agg_type_info.is_geometry()) {
1152  throw std::runtime_error(
1153  "MAX on strings, arrays or geospatial types not supported yet");
1154  }
1155  result.emplace_back((agg_type_info.is_integer() || agg_type_info.is_time())
1156  ? "agg_max"
1157  : "agg_max_double");
1158  break;
1159  }
1160  case kSUM: {
1161  if (!agg_type_info.is_integer() && !agg_type_info.is_decimal() &&
1162  !agg_type_info.is_fp()) {
1163  throw std::runtime_error("SUM is only valid on integer and floating point");
1164  }
1165  result.emplace_back((agg_type_info.is_integer() || agg_type_info.is_time())
1166  ? "agg_sum"
1167  : "agg_sum_double");
1168  break;
1169  }
1170  case kCOUNT:
1171  result.emplace_back(agg_expr->get_is_distinct() ? "agg_count_distinct"
1172  : "agg_count");
1173  break;
1174  case kSAMPLE: {
1175  // Note that varlen SAMPLE arguments are handled separately above
1176  result.emplace_back(agg_type_info.is_fp() ? "agg_id_double" : "agg_id");
1177  break;
1178  }
1180  result.emplace_back("agg_approximate_count_distinct");
1181  break;
1182  default:
1183  CHECK(false);
1184  }
1185  }
1186  return result;
1187 }
Definition: sqldefs.h:71
Definition: sqldefs.h:71
SQLAgg get_aggtype() const
Definition: Analyzer.h:987
Definition: sqldefs.h:71
#define CHECK(condition)
Definition: Logger.h:187
Definition: sqldefs.h:71
Definition: sqldefs.h:71
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ link_udf_module()

void anonymous_namespace{NativeCodegen.cpp}::link_udf_module ( const std::unique_ptr< llvm::Module > &  udf_module,
llvm::Module &  module,
CgenState cgen_state,
llvm::Linker::Flags  flags = llvm::Linker::Flags::None 
)

Definition at line 544 of file NativeCodegen.cpp.

References logger::FATAL, logger::INFO, LOG, and CgenState::vmap_.

Referenced by Executor::compileWorkUnit().

547  {
548  // throw a runtime error if the target module contains functions
549  // with the same name as in module of UDF functions.
550  for (auto& f : *udf_module.get()) {
551  auto func = module.getFunction(f.getName());
552  if (!(func == nullptr)) {
553  LOG(FATAL) << " Attempt to overwrite " << f.getName().str() << " in "
554  << module.getModuleIdentifier() << " from `"
555  << udf_module->getModuleIdentifier() << "`" << std::endl;
556  throw std::runtime_error(
557  "link_udf_module: *** attempt to overwrite a runtime function with a UDF "
558  "function ***");
559  } else {
560  LOG(INFO) << " Adding " << f.getName().str() << " to "
561  << module.getModuleIdentifier() << " from `"
562  << udf_module->getModuleIdentifier() << "`" << std::endl;
563  }
564  }
565 
566  std::unique_ptr<llvm::Module> udf_module_copy;
567 
568  udf_module_copy = llvm::CloneModule(
569 #if LLVM_VERSION_MAJOR >= 7
570  *udf_module.get(),
571 #else
572  udf_module.get(),
573 #endif
574  cgen_state->vmap_);
575 
576  udf_module_copy->setDataLayout(module.getDataLayout());
577  udf_module_copy->setTargetTriple(module.getTargetTriple());
578 
579  // Initialize linker with module for RuntimeFunctions.bc
580  llvm::Linker ld(module);
581  bool link_error = false;
582 
583  link_error = ld.linkInModule(std::move(udf_module_copy), flags);
584 
585  if (link_error) {
586  throw std::runtime_error("link_udf_module: *** error linking module ***");
587  }
588 }
#define LOG(tag)
Definition: Logger.h:182
llvm::ValueToValueMapTy vmap_
Definition: CgenState.h:267
+ Here is the caller graph for this function:

◆ optimize_ir()

void anonymous_namespace{NativeCodegen.cpp}::optimize_ir ( llvm::Function *  query_func,
llvm::Module *  module,
const std::unordered_set< llvm::Function *> &  live_funcs,
const CompilationOptions co 
)

Definition at line 99 of file NativeCodegen.cpp.

References eliminate_dead_self_recursive_funcs(), LoopStrengthReduction, and CompilationOptions::opt_level_.

Referenced by Executor::compileWorkUnit(), CodeGenerator::generateNativeCPUCode(), and CodeGenerator::generateNativeGPUCode().

102  {
103  llvm::legacy::PassManager pass_manager;
104 
105  pass_manager.add(llvm::createAlwaysInlinerLegacyPass());
106  pass_manager.add(llvm::createPromoteMemoryToRegisterPass());
107 #if LLVM_VERSION_MAJOR >= 7
108  pass_manager.add(llvm::createInstSimplifyLegacyPass());
109 #else
110  pass_manager.add(llvm::createInstructionSimplifierPass());
111 #endif
112  pass_manager.add(llvm::createInstructionCombiningPass());
113  pass_manager.add(llvm::createGlobalOptimizerPass());
114 
115  pass_manager.add(llvm::createLICMPass());
117  pass_manager.add(llvm::createLoopStrengthReducePass());
118  }
119  pass_manager.run(*module);
120 
121  eliminate_dead_self_recursive_funcs(*module, live_funcs);
122 }
const ExecutorOptLevel opt_level_
void eliminate_dead_self_recursive_funcs(llvm::Module &M, const std::unordered_set< llvm::Function *> &live_funcs)
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ set_row_func_argnames()

void anonymous_namespace{NativeCodegen.cpp}::set_row_func_argnames ( llvm::Function *  row_func,
const size_t  in_col_count,
const size_t  agg_col_count,
const bool  hoist_literals 
)

Definition at line 950 of file NativeCodegen.cpp.

References agg_col_count, and to_string().

Referenced by create_row_function().

953  {
954  auto arg_it = row_func->arg_begin();
955 
956  if (agg_col_count) {
957  for (size_t i = 0; i < agg_col_count; ++i) {
958  arg_it->setName("out");
959  ++arg_it;
960  }
961  } else {
962  arg_it->setName("group_by_buff");
963  ++arg_it;
964  arg_it->setName("crt_matched");
965  ++arg_it;
966  arg_it->setName("total_matched");
967  ++arg_it;
968  arg_it->setName("old_total_matched");
969  ++arg_it;
970  arg_it->setName("max_matched");
971  ++arg_it;
972  }
973 
974  arg_it->setName("agg_init_val");
975  ++arg_it;
976 
977  arg_it->setName("pos");
978  ++arg_it;
979 
980  arg_it->setName("frag_row_off");
981  ++arg_it;
982 
983  arg_it->setName("num_rows_per_scan");
984  ++arg_it;
985 
986  if (hoist_literals) {
987  arg_it->setName("literals");
988  ++arg_it;
989  }
990 
991  for (size_t i = 0; i < in_col_count; ++i) {
992  arg_it->setName("col_buf" + std::to_string(i));
993  ++arg_it;
994  }
995 
996  arg_it->setName("join_hash_tables");
997 }
const int64_t const uint32_t const uint32_t const uint32_t agg_col_count
std::string to_string(char const *&&v)
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ cuda_rt_decls

const std::string anonymous_namespace{NativeCodegen.cpp}::cuda_rt_decls

Definition at line 333 of file NativeCodegen.cpp.