TargetExprCodegenBuilder Struct Reference

#include <TargetExprBuilder.h>

Collaboration diagram for TargetExprCodegenBuilder:

Public Member Functions
	TargetExprCodegenBuilder (const RelAlgExecutionUnit &ra_exe_unit, const bool is_group_by)
void	operator() (const Analyzer::Expr *target_expr, const Executor *executor, QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co)
void	codegen (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const GpuSharedMemoryContext &gpu_smem_context, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, llvm::Value *varlen_output_buffer, DiamondCodegen &diamond_codegen) const
void	codegenSampleExpressions (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
void	codegenSingleSlotSampleExpression (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
void	codegenMultiSlotSampleExpressions (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
llvm::Value *	codegenSlotEmptyKey (llvm::Value *agg_col_ptr, std::vector< llvm::Value * > &target_lvs, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const int64_t init_val) const

Public Attributes
size_t	target_index_counter {0}
size_t	slot_index_counter {0}
const RelAlgExecutionUnit &	ra_exe_unit
std::vector< TargetExprCodegen >	target_exprs_to_codegen
std::vector< TargetExprCodegen >	sample_exprs_to_codegen
bool	is_group_by

Detailed Description

Definition at line 81 of file TargetExprBuilder.h.

Constructor & Destructor Documentation

TargetExprCodegenBuilder::TargetExprCodegenBuilder ( const RelAlgExecutionUnit &  ra_exe_unit, const bool  is_group_by  )

inline

Definition at line 82 of file TargetExprBuilder.h.

      : ra_exe_unit(ra_exe_unit), is_group_by(is_group_by) {}

Member Function Documentation

void TargetExprCodegenBuilder::codegen	(	GroupByAndAggregate *	group_by_and_agg,
		Executor *	executor,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co,
		const GpuSharedMemoryContext &	gpu_smem_context,
		const std::tuple< llvm::Value *, llvm::Value * > &	agg_out_ptr_w_idx,
		const std::vector< llvm::Value * > &	agg_out_vec,
		llvm::Value *	output_buffer_byte_stream,
		llvm::Value *	out_row_idx,
		llvm::Value *	varlen_output_buffer,
		DiamondCodegen &	diamond_codegen
	)		const

Definition at line 744 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, and CHECK.

Referenced by GroupByAndAggregate::codegenAggCalls().

                                           {
  CHECK(group_by_and_agg);
  CHECK(executor);
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());

  // check the target_exprs and find a set of exprs need non-lazy fetch before entering
  // the expr compilation to avoid a crash during the codegen due to a wrong
  // classification of expr fetch type (lazy vs. non-lazy), and also we can avoid
  // unnecessary query recompilation due to `CompilationRetryNoLazyFetch` exception
  executor->plan_state_->registerNonLazyFetchExpression(target_exprs_to_codegen);

  for (const auto& target_expr_codegen : target_exprs_to_codegen) {
    target_expr_codegen.codegen(group_by_and_agg,
                                executor,
                                query_mem_desc,
                                co,
                                gpu_smem_context,
                                agg_out_ptr_w_idx,
                                agg_out_vec,
                                output_buffer_byte_stream,
                                out_row_idx,
                                varlen_output_buffer,
                                diamond_codegen);
  }
  if (!sample_exprs_to_codegen.empty()) {
    codegenSampleExpressions(group_by_and_agg,
                             executor,
                             query_mem_desc,
                             co,
                             agg_out_ptr_w_idx,
                             agg_out_vec,
                             output_buffer_byte_stream,
                             out_row_idx,
                             diamond_codegen);
  }
}

Here is the caller graph for this function:

void TargetExprCodegenBuilder::codegenMultiSlotSampleExpressions	(	GroupByAndAggregate *	group_by_and_agg,
		Executor *	executor,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co,
		const std::tuple< llvm::Value *, llvm::Value * > &	agg_out_ptr_w_idx,
		const std::vector< llvm::Value * > &	agg_out_vec,
		llvm::Value *	output_buffer_byte_stream,
		llvm::Value *	out_row_idx,
		DiamondCodegen &	diamond_codegen
	)		const

Definition at line 857 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CHECK_GE, CHECK_LT, GroupByAndAggregate::codegenAggArg(), GroupByAndAggregate::codegenAggColumnPtr(), CompilationOptions::device_type, anonymous_namespace{TargetExprBuilder.cpp}::get_initial_agg_val(), GPU, TargetExprCodegen::is_group_by, and QueryMemoryDescriptor::isLogicalSizedColumnsAllowed().

                                           {
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
  CHECK(sample_exprs_to_codegen.size() > 1 ||
        sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
  CHECK(co.device_type == ExecutorDeviceType::GPU);
  const auto& first_sample_expr = sample_exprs_to_codegen.front();
  auto target_lvs = group_by_and_agg->codegenAggArg(first_sample_expr.target_expr, co);
  CHECK_GE(target_lvs.size(), size_t(1));

  const auto init_val =
      get_initial_agg_val(first_sample_expr.target_info, query_mem_desc);

  llvm::Value* agg_col_ptr{nullptr};
  if (is_group_by) {
    const auto agg_column_size_bytes =
        query_mem_desc.isLogicalSizedColumnsAllowed() &&
                !first_sample_expr.target_info.sql_type.is_varlen()
            ? first_sample_expr.target_info.sql_type.get_size()
            : sizeof(int64_t);
    agg_col_ptr = group_by_and_agg->codegenAggColumnPtr(output_buffer_byte_stream,
                                                        out_row_idx,
                                                        agg_out_ptr_w_idx,
                                                        query_mem_desc,
                                                        agg_column_size_bytes,
                                                        first_sample_expr.base_slot_index,
                                                        first_sample_expr.target_idx);
  } else {
    CHECK_LT(static_cast<size_t>(first_sample_expr.base_slot_index), agg_out_vec.size());
    agg_col_ptr =
        executor->castToIntPtrTyIn(agg_out_vec[first_sample_expr.base_slot_index], 64);
  }

  auto sample_cas_lv =
      codegenSlotEmptyKey(agg_col_ptr, target_lvs, executor, query_mem_desc, init_val);

  DiamondCodegen sample_cfg(
      sample_cas_lv, executor, false, "sample_valcheck", &diamond_codegen, false);

  for (const auto& target_expr_codegen : sample_exprs_to_codegen) {
    target_expr_codegen.codegen(group_by_and_agg,
                                executor,
                                query_mem_desc,
                                co,
                                {},
                                agg_out_ptr_w_idx,
                                agg_out_vec,
                                output_buffer_byte_stream,
                                out_row_idx,
                                /*varlen_output_buffer=*/nullptr,
                                diamond_codegen,
                                &sample_cfg);
  }
}

Here is the call graph for this function:

void TargetExprCodegenBuilder::codegenSampleExpressions	(	GroupByAndAggregate *	group_by_and_agg,
		Executor *	executor,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co,
		const std::tuple< llvm::Value *, llvm::Value * > &	agg_out_ptr_w_idx,
		const std::vector< llvm::Value * > &	agg_out_vec,
		llvm::Value *	output_buffer_byte_stream,
		llvm::Value *	out_row_idx,
		DiamondCodegen &	diamond_codegen
	)		const

Definition at line 792 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CompilationOptions::device_type, and GPU.

                                           {
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
  CHECK(!sample_exprs_to_codegen.empty());
  CHECK(co.device_type == ExecutorDeviceType::GPU);
  if (sample_exprs_to_codegen.size() == 1 &&
      !sample_exprs_to_codegen.front().target_info.sql_type.is_varlen()) {
    codegenSingleSlotSampleExpression(group_by_and_agg,
                                      executor,
                                      query_mem_desc,
                                      co,
                                      agg_out_ptr_w_idx,
                                      agg_out_vec,
                                      output_buffer_byte_stream,
                                      out_row_idx,
                                      diamond_codegen);
  } else {
    codegenMultiSlotSampleExpressions(group_by_and_agg,
                                      executor,
                                      query_mem_desc,
                                      co,
                                      agg_out_ptr_w_idx,
                                      agg_out_vec,
                                      output_buffer_byte_stream,
                                      out_row_idx,
                                      diamond_codegen);
  }
}

void TargetExprCodegenBuilder::codegenSingleSlotSampleExpression	(	GroupByAndAggregate *	group_by_and_agg,
		Executor *	executor,
		const QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co,
		const std::tuple< llvm::Value *, llvm::Value * > &	agg_out_ptr_w_idx,
		const std::vector< llvm::Value * > &	agg_out_vec,
		llvm::Value *	output_buffer_byte_stream,
		llvm::Value *	out_row_idx,
		DiamondCodegen &	diamond_codegen
	)		const

Definition at line 829 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CHECK_EQ, CompilationOptions::device_type, and GPU.

                                           {
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
  CHECK_EQ(size_t(1), sample_exprs_to_codegen.size());
  CHECK(!sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
  CHECK(co.device_type == ExecutorDeviceType::GPU);
  // no need for the atomic if we only have one SAMPLE target
  sample_exprs_to_codegen.front().codegen(group_by_and_agg,
                                          executor,
                                          query_mem_desc,
                                          co,
                                          {},
                                          agg_out_ptr_w_idx,
                                          agg_out_vec,
                                          output_buffer_byte_stream,
                                          out_row_idx,
                                          /*varlen_output_buffer=*/nullptr,
                                          diamond_codegen);
}

llvm::Value * TargetExprCodegenBuilder::codegenSlotEmptyKey	(	llvm::Value *	agg_col_ptr,
		std::vector< llvm::Value * > &	target_lvs,
		Executor *	executor,
		const QueryMemoryDescriptor &	query_mem_desc,
		const int64_t	init_val
	)		const

Definition at line 920 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK_EQ, get_int_type(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), LL_BUILDER, LL_CONTEXT, LL_INT, and UNREACHABLE.

                                  {
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
  const auto& first_sample_expr = sample_exprs_to_codegen.front();
  const auto first_sample_slot_bytes =
      first_sample_expr.target_info.sql_type.is_varlen()
          ? sizeof(int64_t)
          : first_sample_expr.target_info.sql_type.get_size();
  llvm::Value* target_lv_casted{nullptr};
  // deciding whether proper casting is required for the first sample's slot:
  if (first_sample_expr.target_info.sql_type.is_varlen()) {
    target_lv_casted =
        LL_BUILDER.CreatePtrToInt(target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
  } else if (first_sample_expr.target_info.sql_type.is_fp()) {
    // Initialization value for SAMPLE on a float column should be 0
    CHECK_EQ(init_val, 0);
    if (query_mem_desc.isLogicalSizedColumnsAllowed()) {
      target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
          target_lvs.front(),
          first_sample_slot_bytes == sizeof(float) ? llvm::Type::getInt32Ty(LL_CONTEXT)
                                                   : llvm::Type::getInt64Ty(LL_CONTEXT));
    } else {
      target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
          target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
    }
  } else if (first_sample_slot_bytes != sizeof(int64_t) &&
             !query_mem_desc.isLogicalSizedColumnsAllowed()) {
    target_lv_casted =
        executor->cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                                      target_lvs.front(),
                                                      llvm::Type::getInt64Ty(LL_CONTEXT));
  } else {
    target_lv_casted = target_lvs.front();
  }

  std::string slot_empty_cas_func_name("slotEmptyKeyCAS");
  llvm::Value* init_val_lv{LL_INT(init_val)};
  if (query_mem_desc.isLogicalSizedColumnsAllowed() &&
      !first_sample_expr.target_info.sql_type.is_varlen()) {
    // add proper suffix to the function name:
    switch (first_sample_slot_bytes) {
      case 1:
        slot_empty_cas_func_name += "_int8";
        break;
      case 2:
        slot_empty_cas_func_name += "_int16";
        break;
      case 4:
        slot_empty_cas_func_name += "_int32";
        break;
      case 8:
        break;
      default:
        UNREACHABLE() << "Invalid slot size for slotEmptyKeyCAS function.";
        break;
    }
    if (first_sample_slot_bytes != sizeof(int64_t)) {
      init_val_lv = llvm::ConstantInt::get(
          get_int_type(first_sample_slot_bytes * 8, LL_CONTEXT), init_val);
    }
  }

  auto sample_cas_lv = executor->cgen_state_->emitExternalCall(
      slot_empty_cas_func_name,
      llvm::Type::getInt1Ty(executor->cgen_state_->context_),
      {agg_col_ptr, target_lv_casted, init_val_lv});
  return sample_cas_lv;
}

Here is the call graph for this function:

void TargetExprCodegenBuilder::operator()	(	const Analyzer::Expr *	target_expr,
		const Executor *	executor,
		QueryMemoryDescriptor &	query_mem_desc,
		const CompilationOptions &	co
	)

Definition at line 652 of file TargetExprBuilder.cpp.

References agg_arg(), anonymous_namespace{TargetExprBuilder.cpp}::agg_fn_base_names(), TargetInfo::agg_kind, AUTOMATIC_IR_METADATA, CHECK, CHECK_EQ, constrained_not_null(), CompilationOptions::device_type, g_bigint_count, get_target_info(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getQueryDescriptionType(), GPU, TargetInfo::is_agg, anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), TargetExprCodegen::is_group_by, anonymous_namespace{TargetExprBuilder.cpp}::is_varlen_projection(), kAPPROX_QUANTILE, kSAMPLE, kSINGLE_VALUE, kUNNEST, heavyai::NonGroupedAggregate, QueryMemoryDescriptor::setPaddedSlotWidthBytes(), TargetInfo::skip_null_val, TargetInfo::sql_type, TargetExprCodegen::target_info, to_string(), and VLOG.

                                                                        {
  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
  if (query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter) == 0) {
    CHECK(!dynamic_cast<const Analyzer::AggExpr*>(target_expr));
    ++slot_index_counter;
    ++target_index_counter;
    return;
  }
  if (dynamic_cast<const Analyzer::UOper*>(target_expr) &&
      static_cast<const Analyzer::UOper*>(target_expr)->get_optype() == kUNNEST) {
    throw std::runtime_error("UNNEST not supported in the projection list yet.");
  }
  if ((executor->plan_state_->isLazyFetchColumn(target_expr) || !is_group_by) &&
      (static_cast<size_t>(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter)) <
       sizeof(int64_t)) &&
      !is_columnar_projection(query_mem_desc)) {
    // TODO(miyu): enable different byte width in the layout w/o padding
    VLOG(2) << "Throw CompilationRetryNoCompaction exception";
    throw CompilationRetryNoCompaction();
  }

  if (is_columnar_projection(query_mem_desc) &&
      executor->plan_state_->isLazyFetchColumn(target_expr)) {
    // For columnar outputs, we need to pad lazy fetched columns to 8 bytes to allow the
    // lazy fetch index to be placed in the column. The QueryMemoryDescriptor is created
    // before Lazy Fetch information is known, therefore we need to update the QMD with
    // the new slot size width bytes for these columns.
    VLOG(2) << "Set padded slot-width byte for the slot-"
            << std::to_string(slot_index_counter) << " to 8";
    query_mem_desc.setPaddedSlotWidthBytes(slot_index_counter, int8_t(8));
    CHECK_EQ(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter), int8_t(8));
  }

  auto target_info = get_target_info(target_expr, g_bigint_count);
  auto arg_expr = agg_arg(target_expr);
  if (arg_expr) {
    if (target_info.agg_kind == kSINGLE_VALUE || target_info.agg_kind == kSAMPLE ||
        target_info.agg_kind == kAPPROX_QUANTILE) {
      target_info.skip_null_val = false;
    } else if (query_mem_desc.getQueryDescriptionType() ==
                   QueryDescriptionType::NonGroupedAggregate &&
               !arg_expr->get_type_info().is_varlen()) {
      // TODO: COUNT is currently not null-aware for varlen types. Need to add proper code
      // generation for handling varlen nulls.
      target_info.skip_null_val = true;
    } else if (constrained_not_null(arg_expr, ra_exe_unit.quals)) {
      target_info.skip_null_val = false;
    }
  }

  if (!(query_mem_desc.getQueryDescriptionType() ==
        QueryDescriptionType::NonGroupedAggregate) &&
      (co.device_type == ExecutorDeviceType::GPU) && target_info.is_agg &&
      (target_info.agg_kind == kSAMPLE)) {
    sample_exprs_to_codegen.emplace_back(target_expr,
                                         target_info,
                                         slot_index_counter,
                                         target_index_counter++,
                                         is_group_by);
  } else {
    target_exprs_to_codegen.emplace_back(target_expr,
                                         target_info,
                                         slot_index_counter,
                                         target_index_counter++,
                                         is_group_by);
  }

  const auto agg_fn_names = agg_fn_base_names(
      target_info, is_varlen_projection(target_expr, target_info.sql_type));
  slot_index_counter += agg_fn_names.size();
}

Here is the call graph for this function:

Member Data Documentation

bool TargetExprCodegenBuilder::is_group_by

Definition at line 149 of file TargetExprBuilder.h.

const RelAlgExecutionUnit& TargetExprCodegenBuilder::ra_exe_unit

Definition at line 144 of file TargetExprBuilder.h.

std::vector<TargetExprCodegen> TargetExprCodegenBuilder::sample_exprs_to_codegen

Definition at line 147 of file TargetExprBuilder.h.

size_t TargetExprCodegenBuilder::slot_index_counter {0}

Definition at line 142 of file TargetExprBuilder.h.

std::vector<TargetExprCodegen> TargetExprCodegenBuilder::target_exprs_to_codegen

Definition at line 146 of file TargetExprBuilder.h.

size_t TargetExprCodegenBuilder::target_index_counter {0}

Definition at line 141 of file TargetExprBuilder.h.

---

The documentation for this struct was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TargetExprBuilder.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TargetExprBuilder.cpp