anonymous_namespace{ResultSetReductionJIT.cpp} Namespace Reference

Functions
Value *	emit_load (Value *ptr, Type ptr_type, Function *function)
Value *	emit_load_i32 (Value *ptr, Function *function)
Value *	emit_load_i64 (Value *ptr, Function *function)
Value *	emit_read_int_from_buff (Value *ptr, const int8_t compact_sz, Function *function)
void	emit_aggregate_one_value (const std::string &agg_kind, Value *val_ptr, Value *other_ptr, const size_t chosen_bytes, const TargetInfo &agg_info, Function *ir_reduce_one_entry)
void	emit_aggregate_one_nullable_value (SQLAgg const sql_agg, Value *val_ptr, Value *other_ptr, const int64_t init_val, const size_t chosen_bytes, const TargetInfo &agg_info, Function *ir_reduce_one_entry)
void	emit_aggregate_one_count (Value *val_ptr, Value *other_ptr, const size_t chosen_bytes, Function *ir_reduce_one_entry)
void	emit_write_projection (Value *slot_pi8, Value *other_pi8, const int64_t init_val, const size_t chosen_bytes, Function *ir_reduce_one_entry)
const Value *	emit_checked_write_projection (Value *slot_pi8, Value *other_pi8, const int64_t init_val, const size_t chosen_bytes, Function *ir_reduce_one_entry)
std::unique_ptr< Function >	create_function (const std::string name, const std::vector< Function::NamedArg > &arg_types, const Type ret_type, const bool always_inline)
std::unique_ptr< Function >	setup_is_empty_entry (ReductionCode *reduction_code)
std::unique_ptr< Function >	setup_reduce_one_entry (ReductionCode *reduction_code, const QueryDescriptionType hash_type)
std::unique_ptr< Function >	setup_reduce_one_entry_idx (ReductionCode *reduction_code)
std::unique_ptr< Function >	setup_reduce_loop (ReductionCode *reduction_code)
llvm::Function *	create_llvm_function (const Function *function, CgenState *cgen_state)
ReductionCode	setup_functions_ir (const QueryDescriptionType hash_type)
bool	is_aggregate_query (const QueryDescriptionType hash_type)
void	varlen_buffer_sample (int8_t *this_ptr1, int8_t *this_ptr2, const int8_t *that_ptr1, const int8_t *that_ptr2, const int64_t init_val)
void	generate_loop_body (For *for_loop, Function *ir_reduce_loop, Function *ir_reduce_one_entry_idx, Value *this_buff, Value *that_buff, Value *start_index, Value *that_entry_count, Value *this_qmd_handle, Value *that_qmd_handle, Value *serialized_varlen_buffer)
std::string	target_info_key (const TargetInfo &target_info)

Variables
const int32_t	WATCHDOG_ERROR
const int32_t	INTERRUPT_ERROR {10}
const size_t	INTERP_THRESHOLD {25}

Function Documentation

std::unique_ptr<Function> anonymous_namespace{ResultSetReductionJIT.cpp}::create_function	(	const std::string	name,
		const std::vector< Function::NamedArg > &	arg_types,
		const Type	ret_type,
		const bool	always_inline
	)

Definition at line 275 of file ResultSetReductionJIT.cpp.

References setup::name.

Referenced by setup_is_empty_entry(), setup_reduce_loop(), setup_reduce_one_entry(), and setup_reduce_one_entry_idx().

                              {
  return std::make_unique<Function>(name, arg_types, ret_type, always_inline);
}

Here is the caller graph for this function:

llvm::Function* anonymous_namespace{ResultSetReductionJIT.cpp}::create_llvm_function	(	const Function *	function,
		CgenState *	cgen_state
	)

Definition at line 351 of file ResultSetReductionJIT.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CgenState::context_, llvm_type(), mark_function_always_inline(), CgenState::module_, setup::name, and Void.

Referenced by ResultSetReductionJIT::codegen(), and GpuReductionHelperJIT::codegen().

                                                                                    {
  AUTOMATIC_IR_METADATA(cgen_state);
  auto& ctx = cgen_state->context_;
  std::vector<llvm::Type*> parameter_types;
  const auto& arg_types = function->arg_types();
  for (const auto& named_arg : arg_types) {
    CHECK(named_arg.type != Type::Void);
    parameter_types.push_back(llvm_type(named_arg.type, ctx));
  }
  const auto func_type = llvm::FunctionType::get(
      llvm_type(function->ret_type(), ctx), parameter_types, false);
  const auto linkage = function->always_inline() ? llvm::Function::PrivateLinkage
                                                 : llvm::Function::ExternalLinkage;
  auto func =
      llvm::Function::Create(func_type, linkage, function->name(), cgen_state->module_);
  const auto arg_it = func->arg_begin();
  for (size_t i = 0; i < arg_types.size(); ++i) {
    const auto arg = &*(arg_it + i);
    arg->setName(arg_types[i].name);
  }
  if (function->always_inline()) {
    mark_function_always_inline(func);
  }
  return func;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_count	(	Value *	val_ptr,
		Value *	other_ptr,
		const size_t	chosen_bytes,
		Function *	ir_reduce_one_entry
	)

Definition at line 185 of file ResultSetReductionJIT.cpp.

References Cast::BitCast, CHECK_EQ, emit_load(), Int32Ptr, and Int64Ptr.

Referenced by ResultSetReductionJIT::reduceOneAggregateSlot().

                                                             {
  const auto dest_name = "count_dest";
  if (chosen_bytes == sizeof(int32_t)) {
    const auto agg = ir_reduce_one_entry->add<Cast>(
        Cast::CastOp::BitCast, val_ptr, Type::Int32Ptr, dest_name);
    const auto val = emit_load(other_ptr, Type::Int32Ptr, ir_reduce_one_entry);
    ir_reduce_one_entry->add<Call>(
        "agg_sum_int32", std::vector<const Value*>{agg, val}, "");
  } else {
    CHECK_EQ(chosen_bytes, sizeof(int64_t));
    const auto agg = ir_reduce_one_entry->add<Cast>(
        Cast::CastOp::BitCast, val_ptr, Type::Int64Ptr, dest_name);
    const auto val = emit_load(other_ptr, Type::Int64Ptr, ir_reduce_one_entry);
    ir_reduce_one_entry->add<Call>("agg_sum", std::vector<const Value*>{agg, val}, "");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_nullable_value	(	SQLAgg const	sql_agg,
		Value *	val_ptr,
		Value *	other_ptr,
		const int64_t	init_val,
		const size_t	chosen_bytes,
		const TargetInfo &	agg_info,
		Function *	ir_reduce_one_entry
	)

Definition at line 125 of file ResultSetReductionJIT.cpp.

References run_benchmark_import::args, Cast::BitCast, CHECK_EQ, Double, DoublePtr, emit_aggregate_one_value(), emit_load(), Float, FloatPtr, get_compact_type(), get_non_conditional_agg_type(), Int32, Int32Ptr, Int64, Int64Ptr, TargetInfo::skip_null_val, to_lower(), and toString().

Referenced by ResultSetReductionJIT::reduceOneAggregateSlot().

                                                                      {
  const std::string agg_kind = to_lower(toString(get_non_conditional_agg_type(sql_agg)));
  const auto dest_name = agg_kind + "_dest";
  if (agg_info.skip_null_val) {
    const auto sql_type = get_compact_type(agg_info);
    if (sql_type.is_fp()) {
      if (chosen_bytes == sizeof(float)) {
        const auto agg = ir_reduce_one_entry->add<Cast>(
            Cast::CastOp::BitCast, val_ptr, Type::Int32Ptr, dest_name);
        const auto val = emit_load(other_ptr, Type::FloatPtr, ir_reduce_one_entry);
        const auto init_val_lv = ir_reduce_one_entry->addConstant<ConstantFP>(
            *reinterpret_cast<const float*>(may_alias_ptr(&init_val)), Type::Float);
        std::vector<const Value*> args{agg, val, init_val_lv};
        ir_reduce_one_entry->add<Call>("agg_" + agg_kind + "_float_skip_val", args, "");
      } else {
        CHECK_EQ(chosen_bytes, sizeof(double));
        const auto agg = ir_reduce_one_entry->add<Cast>(
            Cast::CastOp::BitCast, val_ptr, Type::Int64Ptr, dest_name);
        const auto val = emit_load(other_ptr, Type::DoublePtr, ir_reduce_one_entry);
        const auto init_val_lv = ir_reduce_one_entry->addConstant<ConstantFP>(
            *reinterpret_cast<const double*>(may_alias_ptr(&init_val)), Type::Double);
        ir_reduce_one_entry->add<Call>("agg_" + agg_kind + "_double_skip_val",
                                       std::vector<const Value*>{agg, val, init_val_lv},
                                       "");
      }
    } else {
      if (chosen_bytes == sizeof(int32_t)) {
        const auto agg = ir_reduce_one_entry->add<Cast>(
            Cast::CastOp::BitCast, val_ptr, Type::Int32Ptr, dest_name);
        const auto val = emit_load(other_ptr, Type::Int32Ptr, ir_reduce_one_entry);
        const auto init_val_lv =
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int32);
        ir_reduce_one_entry->add<Call>("agg_" + agg_kind + "_int32_skip_val",
                                       std::vector<const Value*>{agg, val, init_val_lv},
                                       "");
      } else {
        CHECK_EQ(chosen_bytes, sizeof(int64_t));
        const auto agg = ir_reduce_one_entry->add<Cast>(
            Cast::CastOp::BitCast, val_ptr, Type::Int64Ptr, dest_name);
        const auto val = emit_load(other_ptr, Type::Int64Ptr, ir_reduce_one_entry);
        const auto init_val_lv =
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int64);
        ir_reduce_one_entry->add<Call>("agg_" + agg_kind + "_skip_val",
                                       std::vector<const Value*>{agg, val, init_val_lv},
                                       "");
      }
    }
  } else {
    emit_aggregate_one_value(
        agg_kind, val_ptr, other_ptr, chosen_bytes, agg_info, ir_reduce_one_entry);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_value	(	const std::string &	agg_kind,
		Value *	val_ptr,
		Value *	other_ptr,
		const size_t	chosen_bytes,
		const TargetInfo &	agg_info,
		Function *	ir_reduce_one_entry
	)

Definition at line 83 of file ResultSetReductionJIT.cpp.

References Cast::BitCast, CHECK_EQ, DoublePtr, emit_load(), FloatPtr, get_compact_type(), Int32Ptr, and Int64Ptr.

Referenced by emit_aggregate_one_nullable_value().

                                                             {
  const auto sql_type = get_compact_type(agg_info);
  const auto dest_name = agg_kind + "_dest";
  if (sql_type.is_fp()) {
    if (chosen_bytes == sizeof(float)) {
      const auto agg = ir_reduce_one_entry->add<Cast>(
          Cast::CastOp::BitCast, val_ptr, Type::Int32Ptr, dest_name);
      const auto val = emit_load(other_ptr, Type::FloatPtr, ir_reduce_one_entry);
      ir_reduce_one_entry->add<Call>(
          "agg_" + agg_kind + "_float", std::vector<const Value*>{agg, val}, "");
    } else {
      CHECK_EQ(chosen_bytes, sizeof(double));
      const auto agg = ir_reduce_one_entry->add<Cast>(
          Cast::CastOp::BitCast, val_ptr, Type::Int64Ptr, dest_name);
      const auto val = emit_load(other_ptr, Type::DoublePtr, ir_reduce_one_entry);
      ir_reduce_one_entry->add<Call>(
          "agg_" + agg_kind + "_double", std::vector<const Value*>{agg, val}, "");
    }
  } else {
    if (chosen_bytes == sizeof(int32_t)) {
      const auto agg = ir_reduce_one_entry->add<Cast>(
          Cast::CastOp::BitCast, val_ptr, Type::Int32Ptr, dest_name);
      const auto val = emit_load(other_ptr, Type::Int32Ptr, ir_reduce_one_entry);
      ir_reduce_one_entry->add<Call>(
          "agg_" + agg_kind + "_int32", std::vector<const Value*>{agg, val}, "");
    } else {
      CHECK_EQ(chosen_bytes, sizeof(int64_t));
      const auto agg = ir_reduce_one_entry->add<Cast>(
          Cast::CastOp::BitCast, val_ptr, Type::Int64Ptr, dest_name);
      const auto val = emit_load(other_ptr, Type::Int64Ptr, ir_reduce_one_entry);
      ir_reduce_one_entry->add<Call>(
          "agg_" + agg_kind, std::vector<const Value*>{agg, val}, "");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Value* anonymous_namespace{ResultSetReductionJIT.cpp}::emit_checked_write_projection	(	Value *	slot_pi8,
		Value *	other_pi8,
		const int64_t	init_val,
		const size_t	chosen_bytes,
		Function *	ir_reduce_one_entry
	)

Definition at line 239 of file ResultSetReductionJIT.cpp.

References Cast::BitCast, CHECK_EQ, emit_load_i32(), emit_load_i64(), Int32, Int32Ptr, Int64, and Int64Ptr.

Referenced by ResultSetReductionJIT::reduceOneSlot().

                                                                          {
  if (chosen_bytes == sizeof(int32_t)) {
    const auto func_name = "checked_single_agg_id_int32";
    const auto proj_val = emit_load_i32(other_pi8, ir_reduce_one_entry);
    const auto slot_pi32 = ir_reduce_one_entry->add<Cast>(
        Cast::CastOp::BitCast, slot_pi8, Type::Int32Ptr, "");
    return ir_reduce_one_entry->add<Call>(
        func_name,
        Type::Int32,
        std::vector<const Value*>{
            slot_pi32,
            proj_val,
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int32)},
        "");
  } else {
    const auto func_name = "checked_single_agg_id";
    CHECK_EQ(chosen_bytes, sizeof(int64_t));
    const auto proj_val = emit_load_i64(other_pi8, ir_reduce_one_entry);
    const auto slot_pi64 = ir_reduce_one_entry->add<Cast>(
        Cast::CastOp::BitCast, slot_pi8, Type::Int64Ptr, "");

    return ir_reduce_one_entry->add<Call>(
        func_name,
        Type::Int32,
        std::vector<const Value*>{
            slot_pi64,
            proj_val,
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int64)},
        "");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Value* anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load	(	Value *	ptr,
		Type	ptr_type,
		Function *	function
	)

Definition at line 48 of file ResultSetReductionJIT.cpp.

References Cast::BitCast, and Value::label().

Referenced by emit_aggregate_one_count(), emit_aggregate_one_nullable_value(), emit_aggregate_one_value(), emit_load_i32(), and emit_load_i64().

                                                                {
  return function->add<Load>(
      function->add<Cast>(Cast::CastOp::BitCast, ptr, ptr_type, ""),
      ptr->label() + "_loaded");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Value* anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i32	(	Value *	ptr,
		Function *	function
	)

Definition at line 55 of file ResultSetReductionJIT.cpp.

References emit_load(), and Int32Ptr.

Referenced by emit_checked_write_projection(), emit_read_int_from_buff(), emit_write_projection(), and ResultSetReductionJIT::isEmpty().

                                                     {
  return emit_load(ptr, Type::Int32Ptr, function);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Value* anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i64	(	Value *	ptr,
		Function *	function
	)

Definition at line 60 of file ResultSetReductionJIT.cpp.

References emit_load(), and Int64Ptr.

Referenced by emit_checked_write_projection(), emit_read_int_from_buff(), emit_write_projection(), ResultSetReductionJIT::isEmpty(), ResultSetReductionJIT::reduceOneApproxQuantileSlot(), ResultSetReductionJIT::reduceOneCountDistinctSlot(), and ResultSetReductionJIT::reduceOneModeSlot().

                                                     {
  return emit_load(ptr, Type::Int64Ptr, function);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Value* anonymous_namespace{ResultSetReductionJIT.cpp}::emit_read_int_from_buff	(	Value *	ptr,
		const int8_t	compact_sz,
		Function *	function
	)

Definition at line 65 of file ResultSetReductionJIT.cpp.

References emit_load_i32(), emit_load_i64(), logger::FATAL, Int64, LOG, and Cast::SExt.

Referenced by ResultSetReductionJIT::isEmpty().

                                                                                        {
  switch (compact_sz) {
    case 8: {
      return emit_load_i64(ptr, function);
    }
    case 4: {
      const auto loaded_val = emit_load_i32(ptr, function);
      return function->add<Cast>(Cast::CastOp::SExt, loaded_val, Type::Int64, "");
    }
    default: {
      LOG(FATAL) << "Invalid byte width: " << compact_sz;
      return nullptr;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::emit_write_projection	(	Value *	slot_pi8,
		Value *	other_pi8,
		const int64_t	init_val,
		const size_t	chosen_bytes,
		Function *	ir_reduce_one_entry
	)

Definition at line 208 of file ResultSetReductionJIT.cpp.

References CHECK_EQ, emit_load_i32(), emit_load_i64(), Int64, and to_string().

Referenced by ResultSetReductionJIT::reduceOneSlot().

                                                          {
  const auto func_name = "write_projection_int" + std::to_string(chosen_bytes * 8);
  if (chosen_bytes == sizeof(int32_t)) {
    const auto proj_val = emit_load_i32(other_pi8, ir_reduce_one_entry);
    ir_reduce_one_entry->add<Call>(
        func_name,
        std::vector<const Value*>{
            slot_pi8,
            proj_val,
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int64)},
        "");
  } else {
    CHECK_EQ(chosen_bytes, sizeof(int64_t));
    const auto proj_val = emit_load_i64(other_pi8, ir_reduce_one_entry);
    ir_reduce_one_entry->add<Call>(
        func_name,
        std::vector<const Value*>{
            slot_pi8,
            proj_val,
            ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int64)},
        "");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::generate_loop_body	(	For *	for_loop,
		Function *	ir_reduce_loop,
		Function *	ir_reduce_one_entry_idx,
		Value *	this_buff,
		Value *	that_buff,
		Value *	start_index,
		Value *	that_entry_count,
		Value *	this_qmd_handle,
		Value *	that_qmd_handle,
		Value *	serialized_varlen_buffer
	)

Definition at line 982 of file ResultSetReductionJIT.cpp.

References BinaryOperator::Add, For::add(), report::error_code(), g_enable_dynamic_watchdog, g_enable_non_kernel_time_query_interrupt, Int32, Int64, Int8, INTERRUPT_ERROR, For::iter(), ICmp::NE, Cast::SExt, and WATCHDOG_ERROR.

Referenced by ResultSetReductionJIT::reduceLoop().

                                                         {
  const auto that_entry_idx = for_loop->add<BinaryOperator>(
      BinaryOperator::BinaryOp::Add, for_loop->iter(), start_index, "that_entry_idx");
  const auto sample_seed =
      for_loop->add<Cast>(Cast::CastOp::SExt, that_entry_idx, Type::Int64, "");
  if (g_enable_dynamic_watchdog || g_enable_non_kernel_time_query_interrupt) {
    const auto checker_rt_name =
        g_enable_dynamic_watchdog ? "check_watchdog_rt" : "check_interrupt_rt";
    const auto error_code = g_enable_dynamic_watchdog ? WATCHDOG_ERROR : INTERRUPT_ERROR;
    const auto checker_triggered = for_loop->add<ExternalCall>(
        checker_rt_name, Type::Int8, std::vector<const Value*>{sample_seed}, "");
    const auto interrupt_triggered_bool =
        for_loop->add<ICmp>(ICmp::Predicate::NE,
                            checker_triggered,
                            ir_reduce_loop->addConstant<ConstantInt>(0, Type::Int8),
                            "");
    for_loop->add<ReturnEarly>(
        interrupt_triggered_bool,
        ir_reduce_loop->addConstant<ConstantInt>(error_code, Type::Int32),
        "");
  }
  const auto reduce_rc =
      for_loop->add<Call>(ir_reduce_one_entry_idx,
                          std::vector<const Value*>{this_buff,
                                                    that_buff,
                                                    that_entry_idx,
                                                    that_entry_count,
                                                    this_qmd_handle,
                                                    that_qmd_handle,
                                                    serialized_varlen_buffer},
                          "");

  auto reduce_rc_bool =
      for_loop->add<ICmp>(ICmp::Predicate::NE,
                          reduce_rc,
                          ir_reduce_loop->addConstant<ConstantInt>(0, Type::Int32),
                          "");
  for_loop->add<ReturnEarly>(reduce_rc_bool, reduce_rc, "");
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{ResultSetReductionJIT.cpp}::is_aggregate_query

(

const QueryDescriptionType

hash_type

)

Definition at line 388 of file ResultSetReductionJIT.cpp.

References heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, and heavyai::NonGroupedAggregate.

Referenced by ResultSetReductionJIT::codegen(), and ResultSetReductionJIT::isEmpty().

                                                              {
  return hash_type == QueryDescriptionType::GroupByBaselineHash ||
         hash_type == QueryDescriptionType::GroupByPerfectHash ||
         hash_type == QueryDescriptionType::NonGroupedAggregate;
}

Here is the caller graph for this function:

ReductionCode anonymous_namespace{ResultSetReductionJIT.cpp}::setup_functions_ir

(

const QueryDescriptionType

hash_type

)

Definition at line 379 of file ResultSetReductionJIT.cpp.

References ReductionCode::ir_is_empty, setup_is_empty_entry(), setup_reduce_loop(), setup_reduce_one_entry(), and setup_reduce_one_entry_idx().

Referenced by ResultSetReductionJIT::codegen(), and GpuReductionHelperJIT::codegen().

                                                                       {
  ReductionCode reduction_code{};
  reduction_code.ir_is_empty = setup_is_empty_entry(&reduction_code);
  reduction_code.ir_reduce_one_entry = setup_reduce_one_entry(&reduction_code, hash_type);
  reduction_code.ir_reduce_one_entry_idx = setup_reduce_one_entry_idx(&reduction_code);
  reduction_code.ir_reduce_loop = setup_reduce_loop(&reduction_code);
  return reduction_code;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<Function> anonymous_namespace{ResultSetReductionJIT.cpp}::setup_is_empty_entry

(

ReductionCode *

reduction_code

)

Definition at line 285 of file ResultSetReductionJIT.cpp.

References create_function(), Int1, and Int8Ptr.

Referenced by setup_functions_ir().

                                                                            {
  return create_function(
      "is_empty_entry", {{"row_ptr", Type::Int8Ptr}}, Type::Int1, /*always_inline=*/true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<Function> anonymous_namespace{ResultSetReductionJIT.cpp}::setup_reduce_loop

(

ReductionCode *

reduction_code

)

Definition at line 337 of file ResultSetReductionJIT.cpp.

References create_function(), Int32, Int8Ptr, and VoidPtr.

Referenced by setup_functions_ir().

                                                                         {
  return create_function("reduce_loop",
                         {{"this_buff", Type::Int8Ptr},
                          {"that_buff", Type::Int8Ptr},
                          {"start_index", Type::Int32},
                          {"end_index", Type::Int32},
                          {"that_entry_count", Type::Int32},
                          {"this_qmd_handle", Type::VoidPtr},
                          {"that_qmd_handle", Type::VoidPtr},
                          {"serialized_varlen_buffer", Type::VoidPtr}},
                         Type::Int32,
                         /*always_inline=*/false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<Function> anonymous_namespace{ResultSetReductionJIT.cpp}::setup_reduce_one_entry	(	ReductionCode *	reduction_code,
		const QueryDescriptionType	hash_type
	)

Definition at line 291 of file ResultSetReductionJIT.cpp.

References create_function(), logger::FATAL, heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, Int32, Int8Ptr, LOG, heavyai::NonGroupedAggregate, and VoidPtr.

Referenced by setup_functions_ir().

                                                                                       {
  std::string this_ptr_name;
  std::string that_ptr_name;
  switch (hash_type) {
    case QueryDescriptionType::GroupByBaselineHash: {
      this_ptr_name = "this_targets_ptr";
      that_ptr_name = "that_targets_ptr";
      break;
    }
    case QueryDescriptionType::GroupByPerfectHash:
    case QueryDescriptionType::NonGroupedAggregate: {
      this_ptr_name = "this_row_ptr";
      that_ptr_name = "that_row_ptr";
      break;
    }
    default: {
      LOG(FATAL) << "Unexpected query description type";
    }
  }
  return create_function("reduce_one_entry",
                         {{this_ptr_name, Type::Int8Ptr},
                          {that_ptr_name, Type::Int8Ptr},
                          {"this_qmd", Type::VoidPtr},
                          {"that_qmd", Type::VoidPtr},
                          {"serialized_varlen_buffer_arg", Type::VoidPtr}},
                         Type::Int32,
                         /*always_inline=*/true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<Function> anonymous_namespace{ResultSetReductionJIT.cpp}::setup_reduce_one_entry_idx

(

ReductionCode *

reduction_code

)

Definition at line 322 of file ResultSetReductionJIT.cpp.

References create_function(), Int32, Int8Ptr, and VoidPtr.

Referenced by setup_functions_ir().

                                                                                  {
  return create_function("reduce_one_entry_idx",
                         {{"this_buff", Type::Int8Ptr},
                          {"that_buff", Type::Int8Ptr},
                          {"that_entry_idx", Type::Int32},
                          {"that_entry_count", Type::Int32},
                          {"this_qmd_handle", Type::VoidPtr},
                          {"that_qmd_handle", Type::VoidPtr},
                          {"serialized_varlen_buffer", Type::VoidPtr}},
                         Type::Int32,
                         /*always_inline=*/true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{ResultSetReductionJIT.cpp}::target_info_key

(

const TargetInfo &

target_info

)

Definition at line 1295 of file ResultSetReductionJIT.cpp.

References TargetInfo::agg_arg_type, TargetInfo::agg_kind, SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type_name(), TargetInfo::is_agg, TargetInfo::is_distinct, TargetInfo::skip_null_val, TargetInfo::sql_type, and to_string().

Referenced by ResultSetReductionJIT::cacheKey().

                                                         {
  return std::to_string(target_info.is_agg) + "\n" +
         std::to_string(target_info.agg_kind) + "\n" +
         target_info.sql_type.get_type_name() + "\n" +
         std::to_string(target_info.sql_type.get_notnull()) + "\n" +
         target_info.agg_arg_type.get_type_name() + "\n" +
         std::to_string(target_info.agg_arg_type.get_notnull()) + "\n" +
         std::to_string(target_info.skip_null_val) + "\n" +
         std::to_string(target_info.is_distinct);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionJIT.cpp}::varlen_buffer_sample	(	int8_t *	this_ptr1,
		int8_t *	this_ptr2,
		const int8_t *	that_ptr1,
		const int8_t *	that_ptr2,
		const int64_t	init_val
	)

Definition at line 395 of file ResultSetReductionJIT.cpp.

References CHECK.

Referenced by serialized_varlen_buffer_sample().

                                                  {
  const auto rhs_proj_col = *reinterpret_cast<const int64_t*>(that_ptr1);
  if (rhs_proj_col != init_val) {
    *reinterpret_cast<int64_t*>(this_ptr1) = rhs_proj_col;
  }
  CHECK(this_ptr2 && that_ptr2);
  *reinterpret_cast<int64_t*>(this_ptr2) = *reinterpret_cast<const int64_t*>(that_ptr2);
}

Here is the caller graph for this function:

Variable Documentation

const size_t anonymous_namespace{ResultSetReductionJIT.cpp}::INTERP_THRESHOLD {25}

Definition at line 45 of file ResultSetReductionJIT.cpp.

Referenced by ResultSetReductionJIT::codegen().

const int32_t anonymous_namespace{ResultSetReductionJIT.cpp}::INTERRUPT_ERROR {10}

Definition at line 43 of file ResultSetReductionJIT.cpp.

Referenced by generate_loop_body().

const int32_t anonymous_namespace{ResultSetReductionJIT.cpp}::WATCHDOG_ERROR

Definition at line 41 of file ResultSetReductionJIT.cpp.

Referenced by generate_loop_body().