anonymous_namespace{TableFunctionCompilationContext.cpp} Namespace Reference

Functions
llvm::Function *	generate_entry_point (const CgenState *cgen_state)
llvm::Type *	get_llvm_type_from_sql_column_type (const SQLTypeInfo elem_ti, llvm::LLVMContext &ctx)
void	initialize_ptr_member (llvm::Value *member_ptr, llvm::Type *member_llvm_type, llvm::Value *value_ptr, llvm::IRBuilder<> &ir_builder)
void	initialize_int64_member (llvm::Value *member_ptr, llvm::Value *value, int64_t default_value, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
std::tuple< llvm::Value *, llvm::Value * >	alloc_column (std::string col_name, const size_t index, const SQLTypeInfo &data_target_info, llvm::Value *data_ptr, llvm::Value *data_size, llvm::Value *data_str_dict_proxy_ptr, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
llvm::Value *	alloc_column_list (std::string col_list_name, const SQLTypeInfo &data_target_info, llvm::Value *data_ptrs, int length, llvm::Value *data_size, llvm::Value *data_str_dict_proxy_ptrs, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
static bool	columnTypeRequiresCasting (const SQLTypeInfo &ti)
llvm::Value *	cast_value (llvm::Value *value, SQLTypeInfo &orig_ti, SQLTypeInfo &dest_ti, bool nullable, CodeGenerator &codeGenerator)
void	cast_column (llvm::Value *col_base_ptr, llvm::Function *func, SQLTypeInfo &orig_ti, SQLTypeInfo &dest_ti, std::string index, llvm::IRBuilder<> &ir_builder, llvm::LLVMContext &ctx, CodeGenerator &codeGenerator)
std::string	exprsKey (const std::vector< Analyzer::Expr * > &exprs)

Function Documentation

std::tuple<llvm::Value*, llvm::Value*> anonymous_namespace{TableFunctionCompilationContext.cpp}::alloc_column	(	std::string	col_name,
		const size_t	index,
		const SQLTypeInfo &	data_target_info,
		llvm::Value *	data_ptr,
		llvm::Value *	data_size,
		llvm::Value *	data_str_dict_proxy_ptr,
		llvm::LLVMContext &	ctx,
		llvm::IRBuilder<> &	ir_builder
	)

Definition at line 129 of file TableFunctionCompilationContext.cpp.

References SQLTypeInfo::get_compression(), get_llvm_type_from_sql_column_type(), initialize_int64_member(), initialize_ptr_member(), SQLTypeInfo::is_string(), and kENCODING_DICT.

Referenced by TableFunctionCompilationContext::generateEntryPoint().

                                                                                 {
  /*
    Creates a new Column instance of given element type and initialize
    its data ptr and sz members when specified. If data ptr or sz are
    unspecified (have nullptr values) then the corresponding members
    are initialized with NULL and -1, respectively.

    If we are allocating a TextEncodingDict Column type, this function
    adds and populates a int8* pointer to a StringDictProxy object.

    Return a pair of Column allocation (caller should apply
    builder.CreateLoad to it in order to construct a Column instance
    as a value) and a pointer to the Column instance.
   */
  const bool is_text_encoding_dict_type =
      data_target_info.is_string() &&
      data_target_info.get_compression() == kENCODING_DICT;
  llvm::StructType* col_struct_type;
  llvm::Type* data_ptr_llvm_type =
      get_llvm_type_from_sql_column_type(data_target_info, ctx);
  if (is_text_encoding_dict_type) {
    col_struct_type = llvm::StructType::get(
        ctx,
        {
            data_ptr_llvm_type,           /* T* ptr */
            llvm::Type::getInt64Ty(ctx),  /* int64_t sz */
            llvm::Type::getInt8PtrTy(ctx) /* int8_t* string_dictionary_ptr */
        });
  } else {
    col_struct_type =
        llvm::StructType::get(ctx,
                              {
                                  data_ptr_llvm_type,         /* T* ptr */
                                  llvm::Type::getInt64Ty(ctx) /* int64_t sz */
                              });
  }

  auto col = ir_builder.CreateAlloca(col_struct_type);
  col->setName(col_name);
  auto col_ptr_ptr = ir_builder.CreateStructGEP(col_struct_type, col, 0);
  auto col_sz_ptr = ir_builder.CreateStructGEP(col_struct_type, col, 1);
  auto col_str_dict_ptr = is_text_encoding_dict_type
                              ? ir_builder.CreateStructGEP(col_struct_type, col, 2)
                              : nullptr;
  col_ptr_ptr->setName(col_name + ".ptr");
  col_sz_ptr->setName(col_name + ".sz");
  if (is_text_encoding_dict_type) {
    col_str_dict_ptr->setName(col_name + ".string_dict_proxy");
  }

  initialize_ptr_member(col_ptr_ptr, data_ptr_llvm_type, data_ptr, ir_builder);
  initialize_int64_member(col_sz_ptr, data_size, -1, ctx, ir_builder);
  if (is_text_encoding_dict_type) {
    initialize_ptr_member(col_str_dict_ptr,
                          llvm::Type::getInt8PtrTy(ctx),
                          data_str_dict_proxy_ptr,
                          ir_builder);
  }
  auto col_ptr = ir_builder.CreatePointerCast(
      col_ptr_ptr, llvm::PointerType::get(llvm::Type::getInt8Ty(ctx), 0));
  col_ptr->setName(col_name + "_ptr");
  return {col, col_ptr};
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value* anonymous_namespace{TableFunctionCompilationContext.cpp}::alloc_column_list	(	std::string	col_list_name,
		const SQLTypeInfo &	data_target_info,
		llvm::Value *	data_ptrs,
		int	length,
		llvm::Value *	data_size,
		llvm::Value *	data_str_dict_proxy_ptrs,
		llvm::LLVMContext &	ctx,
		llvm::IRBuilder<> &	ir_builder
	)

Definition at line 200 of file TableFunctionCompilationContext.cpp.

References CHECK, SQLTypeInfo::get_compression(), initialize_int64_member(), initialize_ptr_member(), SQLTypeInfo::is_string(), and kENCODING_DICT.

Referenced by TableFunctionCompilationContext::generateEntryPoint().

                                                            {
  /*
    Creates a new ColumnList instance of given element type and initialize
    its members. If data ptr or size are unspecified (have nullptr
    values) then the corresponding members are initialized with NULL
    and -1, respectively.
   */
  llvm::Type* data_ptrs_llvm_type = llvm::Type::getInt8PtrTy(ctx);
  const bool is_text_encoding_dict_type =
      data_target_info.is_string() &&
      data_target_info.get_compression() == kENCODING_DICT;

  llvm::StructType* col_list_struct_type =
      is_text_encoding_dict_type
          ? llvm::StructType::get(
                ctx,
                {
                    data_ptrs_llvm_type,         /* int8_t* ptrs */
                    llvm::Type::getInt64Ty(ctx), /* int64_t length */
                    llvm::Type::getInt64Ty(ctx), /* int64_t size */
                    data_ptrs_llvm_type          /* int8_t* str_dict_proxy_ptrs */
                })
          : llvm::StructType::get(ctx,
                                  {
                                      data_ptrs_llvm_type,         /* int8_t* ptrs */
                                      llvm::Type::getInt64Ty(ctx), /* int64_t length */
                                      llvm::Type::getInt64Ty(ctx)  /* int64_t size */
                                  });

  auto col_list = ir_builder.CreateAlloca(col_list_struct_type);
  col_list->setName(col_list_name);
  auto col_list_ptr_ptr = ir_builder.CreateStructGEP(col_list_struct_type, col_list, 0);
  auto col_list_length_ptr =
      ir_builder.CreateStructGEP(col_list_struct_type, col_list, 1);
  auto col_list_size_ptr = ir_builder.CreateStructGEP(col_list_struct_type, col_list, 2);
  auto col_str_dict_ptr_ptr =
      is_text_encoding_dict_type
          ? ir_builder.CreateStructGEP(col_list_struct_type, col_list, 3)
          : nullptr;

  col_list_ptr_ptr->setName(col_list_name + ".ptrs");
  col_list_length_ptr->setName(col_list_name + ".length");
  col_list_size_ptr->setName(col_list_name + ".size");
  if (is_text_encoding_dict_type) {
    col_str_dict_ptr_ptr->setName(col_list_name + ".string_dict_proxies");
  }

  initialize_ptr_member(col_list_ptr_ptr, data_ptrs_llvm_type, data_ptrs, ir_builder);

  CHECK(length >= 0);
  auto const_length = llvm::ConstantInt::get(llvm::Type::getInt64Ty(ctx), length, true);
  ir_builder.CreateStore(const_length, col_list_length_ptr);

  initialize_int64_member(col_list_size_ptr, data_size, -1, ctx, ir_builder);

  if (is_text_encoding_dict_type) {
    initialize_ptr_member(col_str_dict_ptr_ptr,
                          data_str_dict_proxy_ptrs->getType(),
                          data_str_dict_proxy_ptrs,
                          ir_builder);
  }

  auto col_list_ptr = ir_builder.CreatePointerCast(
      col_list_ptr_ptr, llvm::PointerType::get(llvm::Type::getInt8Ty(ctx), 0));
  col_list_ptr->setName(col_list_name + "_ptrs");
  return col_list_ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{TableFunctionCompilationContext.cpp}::cast_column	(	llvm::Value *	col_base_ptr,
		llvm::Function *	func,
		SQLTypeInfo &	orig_ti,
		SQLTypeInfo &	dest_ti,
		std::string	index,
		llvm::IRBuilder<> &	ir_builder,
		llvm::LLVMContext &	ctx,
		CodeGenerator &	codeGenerator
	)

Definition at line 311 of file TableFunctionCompilationContext.cpp.

References cast_value(), and get_llvm_type_from_sql_column_type().

Referenced by TableFunctionCompilationContext::generateCastsForInputTypes().

                                               {
  /*
  Generates code to cast a Column instance from a given origin
  SQLType to a new destinaton SQLType. To do so, it generates a
  loop with the following overall structure:

     --------------
     | pre_header |
     |   i = 0    |
     --------------
           |
           v
    ----------------              ----------------
    |    cond      |              |     body     |
    | i < col.size |   (True) ->  | cast(col[i]) |
    ----------------              |     i++      |
        (False) ^                 ----------------
           |     \____________________/
           |
           v
    ---------------
    |     end     |
    ---------------

  The correctness of the cast as well as error handling/early
  exiting in case of cast failures are left to the CodeGenerator
  which generates the code for the cast operation itself.
 */

  llvm::BasicBlock* for_pre =
      llvm::BasicBlock::Create(ctx, "for_pre_cast." + index, func);
  llvm::BasicBlock* for_cond =
      llvm::BasicBlock::Create(ctx, "for_cond_cast." + index, func);
  llvm::BasicBlock* for_body =
      llvm::BasicBlock::Create(ctx, "for_body_cast." + index, func);
  llvm::BasicBlock* for_end =
      llvm::BasicBlock::Create(ctx, "for_end_cast." + index, func);
  ir_builder.CreateBr(for_pre);

  // pre-header: load column ptr and size
  ir_builder.SetInsertPoint(for_pre);
  llvm::Type* data_type = get_llvm_type_from_sql_column_type(orig_ti, ctx);
  llvm::StructType* col_struct_type =
      llvm::StructType::get(ctx, {data_type, ir_builder.getInt64Ty()});
  llvm::Value* struct_cast = ir_builder.CreateBitCast(
      col_base_ptr, col_struct_type->getPointerTo(), "col_struct." + index);
  llvm::Value* gep_ptr = ir_builder.CreateStructGEP(
      col_struct_type, struct_cast, 0, "col_ptr_addr." + index);
  llvm::Value* col_ptr = ir_builder.CreateLoad(data_type, gep_ptr, "col_ptr." + index);
  llvm::Value* gep_sz =
      ir_builder.CreateStructGEP(col_struct_type, struct_cast, 1, "col_sz_addr." + index);
  llvm::Value* col_sz =
      ir_builder.CreateLoad(ir_builder.getInt64Ty(), gep_sz, "col_sz." + index);
  ir_builder.CreateBr(for_cond);

  // condition: check induction variable against loop predicate
  ir_builder.SetInsertPoint(for_cond);
  llvm::PHINode* for_ind_var =
      ir_builder.CreatePHI(ir_builder.getInt64Ty(), 2, "for_ind_var." + index);
  for_ind_var->addIncoming(ir_builder.getInt64(0), for_pre);
  llvm::Value* for_pred =
      ir_builder.CreateICmpSLT(for_ind_var, col_sz, "for_pred." + index);
  ir_builder.CreateCondBr(for_pred, for_body, for_end);

  // body: perform value cast, increment induction variable
  ir_builder.SetInsertPoint(for_body);
  ;
  llvm::Value* val_gep = ir_builder.CreateInBoundsGEP(
      ir_builder.getInt64Ty(), col_ptr, for_ind_var, "val_gep." + index);
  llvm::Value* val_load =
      ir_builder.CreateLoad(ir_builder.getInt64Ty(), val_gep, "val_load." + index);
  llvm::Value* cast_result = cast_value(val_load, orig_ti, dest_ti, false, codeGenerator);
  cast_result->setName("cast_result." + index);
  ir_builder.CreateStore(cast_result, val_gep);
  llvm::Value* for_inc =
      ir_builder.CreateAdd(for_ind_var, ir_builder.getInt64(1), "for_inc." + index);
  ir_builder.CreateBr(for_cond);
  // the cast codegening may have generated extra blocks, so for_body does not necessarily
  // jump to for_cond directly
  llvm::Instruction* inc_as_inst = llvm::cast<llvm::Instruction>(for_inc);
  for_ind_var->addIncoming(for_inc, inc_as_inst->getParent());
  ir_builder.SetInsertPoint(for_end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value* anonymous_namespace{TableFunctionCompilationContext.cpp}::cast_value	(	llvm::Value *	value,
		SQLTypeInfo &	orig_ti,
		SQLTypeInfo &	dest_ti,
		bool	nullable,
		CodeGenerator &	codeGenerator
	)

Definition at line 293 of file TableFunctionCompilationContext.cpp.

References CodeGenerator::codegenCastBetweenTimestamps(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type_name(), and SQLTypeInfo::is_timestamp().

Referenced by cast_column().

                                                      {
  /*
  Codegens a cast of a value from a given origin type to a given destination type, if such
  implementation is available. Errors for unsupported casts.
  */
  if (orig_ti.is_timestamp() && dest_ti.is_timestamp()) {
    return codeGenerator.codegenCastBetweenTimestamps(
        value, orig_ti, dest_ti, !dest_ti.get_notnull());
  } else {
    throw std::runtime_error("Unsupported cast from " + orig_ti.get_type_name() + " to " +
                             dest_ti.get_type_name() + " during UDTF code generation.");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool anonymous_namespace{TableFunctionCompilationContext.cpp}::columnTypeRequiresCasting ( const SQLTypeInfo &  ti )

static

Definition at line 275 of file TableFunctionCompilationContext.cpp.

References SQLTypeInfo::get_precision(), SQLTypeInfo::get_subtype(), SQLTypeInfo::is_column(), and kTIMESTAMP.

Referenced by TableFunctionCompilationContext::generateEntryPoint().

                                                             {
  /*
  Returns whether a column requires casting before table function execution based on its
  underlying SQL type
  */

  if (!ti.is_column()) {
    return false;
  }

  // TIMESTAMP columns should always have nanosecond precision
  if (ti.get_subtype() == kTIMESTAMP && ti.get_precision() != 9) {
    return true;
  }

  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{TableFunctionCompilationContext.cpp}::exprsKey

(

const std::vector< Analyzer::Expr * > &

exprs

)

Definition at line 402 of file TableFunctionCompilationContext.cpp.

References run_benchmark_import::result.

Referenced by TableFunctionCompilationContext::compile().

                                                          {
  std::string result;
  for (const auto& expr : exprs) {
    const auto& ti = expr->get_type_info();
    result += ti.to_string() + ", ";
  }
  return result;
}

Here is the caller graph for this function:

llvm::Function* anonymous_namespace{TableFunctionCompilationContext.cpp}::generate_entry_point

(

const CgenState *

cgen_state

)

Definition at line 31 of file TableFunctionCompilationContext.cpp.

References CgenState::context_, get_int_type(), and CgenState::module_.

Referenced by TableFunctionCompilationContext::compile().

                                                                {
  auto& ctx = cgen_state->context_;
  const auto pi8_type = llvm::PointerType::get(get_int_type(8, ctx), 0);
  const auto ppi8_type = llvm::PointerType::get(pi8_type, 0);
  const auto pi64_type = llvm::PointerType::get(get_int_type(64, ctx), 0);
  const auto ppi64_type = llvm::PointerType::get(pi64_type, 0);
  const auto i32_type = get_int_type(32, ctx);

  const auto func_type = llvm::FunctionType::get(
      i32_type,
      {pi8_type, ppi8_type, pi64_type, ppi8_type, ppi64_type, ppi8_type, pi64_type},
      false);

  auto func = llvm::Function::Create(func_type,
                                     llvm::Function::ExternalLinkage,
                                     "call_table_function",
                                     cgen_state->module_);
  auto arg_it = func->arg_begin();
  const auto mgr_arg = &*arg_it;
  mgr_arg->setName("mgr_ptr");
  const auto input_cols_arg = &*(++arg_it);
  input_cols_arg->setName("input_col_buffers");
  const auto input_row_counts = &*(++arg_it);
  input_row_counts->setName("input_row_counts");
  const auto input_str_dict_proxies = &*(++arg_it);
  input_str_dict_proxies->setName("input_str_dict_proxies");
  const auto output_buffers = &*(++arg_it);
  output_buffers->setName("output_buffers");
  const auto output_str_dict_proxies = &*(++arg_it);
  output_str_dict_proxies->setName("output_str_dict_proxies");
  const auto output_row_count = &*(++arg_it);
  output_row_count->setName("output_row_count");
  return func;
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Type* anonymous_namespace{TableFunctionCompilationContext.cpp}::get_llvm_type_from_sql_column_type ( const SQLTypeInfo  elem_ti, llvm::LLVMContext &  ctx  )

inline

Definition at line 66 of file TableFunctionCompilationContext.cpp.

References CHECK, logger::FATAL, SQLTypeInfo::get_compression(), get_fp_ptr_type(), get_int_ptr_type(), SQLTypeInfo::get_size(), SQLTypeInfo::is_array(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_bytes(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_timestamp(), kENCODING_DICT, LOG, and toString().

Referenced by alloc_column(), and cast_column().

                                                                            {
  if (elem_ti.is_fp()) {
    return get_fp_ptr_type(elem_ti.get_size() * 8, ctx);
  } else if (elem_ti.is_boolean()) {
    return get_int_ptr_type(8, ctx);
  } else if (elem_ti.is_integer()) {
    return get_int_ptr_type(elem_ti.get_size() * 8, ctx);
  } else if (elem_ti.is_string()) {
    if (elem_ti.get_compression() == kENCODING_DICT) {
      return get_int_ptr_type(elem_ti.get_size() * 8, ctx);
    }
    CHECK(elem_ti.is_bytes());  // None encoded string
    return get_int_ptr_type(8, ctx);
  } else if (elem_ti.is_timestamp()) {
    return get_int_ptr_type(elem_ti.get_size() * 8, ctx);
  } else if (elem_ti.is_array()) {
    return get_int_ptr_type(8, ctx);
  }
  LOG(FATAL) << "get_llvm_type_from_sql_column_type: not implemented for "
             << ::toString(elem_ti);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{TableFunctionCompilationContext.cpp}::initialize_int64_member	(	llvm::Value *	member_ptr,
		llvm::Value *	value,
		int64_t	default_value,
		llvm::LLVMContext &	ctx,
		llvm::IRBuilder<> &	ir_builder
	)

Definition at line 106 of file TableFunctionCompilationContext.cpp.

References CHECK.

Referenced by alloc_column(), and alloc_column_list().

                                                          {
  llvm::Value* val = nullptr;
  if (value != nullptr) {
    auto value_type = value->getType();
    if (value_type->isPointerTy()) {
      CHECK(value_type->getPointerElementType()->isIntegerTy(64));
      val = ir_builder.CreateLoad(value->getType()->getPointerElementType(), value);
    } else {
      CHECK(value_type->isIntegerTy(64));
      val = value;
    }
    ir_builder.CreateStore(val, member_ptr);
  } else {
    auto const_default =
        llvm::ConstantInt::get(llvm::Type::getInt64Ty(ctx), default_value, true);
    ir_builder.CreateStore(const_default, member_ptr);
  }
}

Here is the caller graph for this function:

void anonymous_namespace{TableFunctionCompilationContext.cpp}::initialize_ptr_member	(	llvm::Value *	member_ptr,
		llvm::Type *	member_llvm_type,
		llvm::Value *	value_ptr,
		llvm::IRBuilder<> &	ir_builder
	)

Definition at line 90 of file TableFunctionCompilationContext.cpp.

Referenced by alloc_column(), and alloc_column_list().

                                                        {
  if (value_ptr != nullptr) {
    if (value_ptr->getType() == member_llvm_type->getPointerElementType()) {
      ir_builder.CreateStore(value_ptr, member_ptr);
    } else {
      auto tmp = ir_builder.CreateBitCast(value_ptr, member_llvm_type);
      ir_builder.CreateStore(tmp, member_ptr);
    }
  } else {
    ir_builder.CreateStore(llvm::Constant::getNullValue(member_llvm_type), member_ptr);
  }
}

Here is the caller graph for this function: