#include <ResultSetReductionJIT.h>

Inheritance diagram for ResultSetReductionJIT:

Collaboration diagram for ResultSetReductionJIT:

Public Member Functions
	ResultSetReductionJIT (const QueryMemoryDescriptor &query_mem_desc, const std::vector< TargetInfo > &targets, const std::vector< int64_t > &target_init_vals, const size_t executor_id)

virtual	~ResultSetReductionJIT ()=default

virtual ReductionCode	codegen () const

Protected Member Functions
void	isEmpty (const ReductionCode &reduction_code) const

void	reduceOneEntryNoCollisions (const ReductionCode &reduction_code) const

void	reduceOneEntryNoCollisionsIdx (const ReductionCode &reduction_code) const

void	reduceLoop (const ReductionCode &reduction_code) const

Protected Attributes
size_t	executor_id_

Private Member Functions
void	reduceOneEntryTargetsNoCollisions (Function ir_reduce_one_entry, Value this_targets_start_ptr, Value *that_targets_start_ptr) const

void	reduceOneEntryBaseline (const ReductionCode &reduction_code) const

void	reduceOneEntryBaselineIdx (const ReductionCode &reduction_code) const

void	reduceOneSlot (Value this_ptr1, Value this_ptr2, Value that_ptr1, Value that_ptr2, const TargetInfo &target_info, const size_t target_logical_idx, const size_t target_slot_idx, const size_t init_agg_val_idx, const size_t first_slot_idx_for_target, Function *ir_reduce_one_entry) const

void	reduceOneAggregateSlot (Value this_ptr1, Value this_ptr2, Value that_ptr1, Value that_ptr2, const TargetInfo &target_info, const size_t target_logical_idx, const size_t target_slot_idx, const int64_t init_val, const int8_t chosen_bytes, Function *ir_reduce_one_entry) const

void	reduceOneCountDistinctSlot (Value this_ptr1, Value that_ptr1, const size_t target_logical_idx, Function *ir_reduce_one_entry) const

void	reduceOneApproxQuantileSlot (Value this_ptr1, Value that_ptr1, const size_t target_logical_idx, Function *ir_reduce_one_entry) const

void	reduceOneModeSlot (Value this_ptr1, Value that_ptr1, const size_t target_logical_idx, Function *ir_reduce_one_entry) const

void	finalizeReductionCode (ReductionCode &reduction_code, const llvm::Function ir_is_empty, const llvm::Function ir_reduce_one_entry, const llvm::Function *ir_reduce_one_entry_idx, const CodeCacheKey &key) const

std::string	cacheKey () const

Private Attributes
const QueryMemoryDescriptor	query_mem_desc_

const std::vector< TargetInfo >	targets_

const std::vector< int64_t >	target_init_vals_

Detailed Description

Definition at line 52 of file ResultSetReductionJIT.h.

Constructor & Destructor Documentation

ResultSetReductionJIT::ResultSetReductionJIT	(	const QueryMemoryDescriptor &	query_mem_desc,
		const std::vector< TargetInfo > &	targets,
		const std::vector< int64_t > &	target_init_vals,
		const size_t	executor_id
	)

Definition at line 527 of file ResultSetReductionJIT.cpp.

     : executor_id_(executor_id)
     , query_mem_desc_(query_mem_desc)
     , targets_(targets)
     , target_init_vals_(target_init_vals) {}

virtual ResultSetReductionJIT::~ResultSetReductionJIT ( )

virtualdefault

Member Function Documentation

std::string ResultSetReductionJIT::cacheKey ( ) const

private

Definition at line 1308 of file ResultSetReductionJIT.cpp.

References join(), query_mem_desc_, QueryMemoryDescriptor::reductionKey(), anonymous_namespace{ResultSetReductionJIT.cpp}::target_info_key(), target_init_vals_, targets_, to_string(), and shared::transform().

Referenced by codegen().

                                                 {
   std::vector<std::string> target_init_vals_strings;
   std::transform(target_init_vals_.begin(),
                  target_init_vals_.end(),
                  std::back_inserter(target_init_vals_strings),
                  [](const int64_t v) { return std::to_string(v); });
   const auto target_init_vals_key =
       boost::algorithm::join(target_init_vals_strings, ", ");
   std::vector<std::string> targets_strings;
   std::transform(
       targets_.begin(),
       targets_.end(),
       std::back_inserter(targets_strings),
       [](const TargetInfo& target_info) { return target_info_key(target_info); });
   const auto targets_key = boost::algorithm::join(targets_strings, ", ");
   return query_mem_desc_.reductionKey() + "\n" + target_init_vals_key + "\n" +
          targets_key;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ReductionCode ResultSetReductionJIT::codegen ( ) const

virtual

Reimplemented in GpuReductionHelperJIT.

Definition at line 567 of file ResultSetReductionJIT.cpp.

References AUTOMATIC_IR_METADATA, AUTOMATIC_IR_METADATA_DONE, QueryMemoryDescriptor::blocksShareMemory(), cacheKey(), anonymous_namespace{ResultSetReductionJIT.cpp}::create_llvm_function(), QueryMemoryDescriptor::didOutputColumnar(), executor_id_, f(), logger::FATAL, finalizeReductionCode(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getExecutor(), Executor::getExecutor(), QueryEngine::getInstance(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, anonymous_namespace{ResultSetReductionJIT.cpp}::INTERP_THRESHOLD, anonymous_namespace{ResultSetReductionJIT.cpp}::is_aggregate_query(), isEmpty(), LOG, heavyai::NonGroupedAggregate, query_mem_desc_, reduceLoop(), reduceOneEntryBaseline(), reduceOneEntryBaselineIdx(), reduceOneEntryNoCollisions(), reduceOneEntryNoCollisionsIdx(), anonymous_namespace{ResultSetReductionJIT.cpp}::setup_functions_ir(), and translate_function().

Referenced by anonymous_namespace{Execute.cpp}::get_reduction_code(), and ResultSetManager::reduce().

                                                    {
   const auto hash_type = query_mem_desc_.getQueryDescriptionType();
   if (query_mem_desc_.didOutputColumnar() || !is_aggregate_query(hash_type)) {
     return {};
   }
   auto reduction_code = setup_functions_ir(hash_type);
   isEmpty(reduction_code);
   switch (query_mem_desc_.getQueryDescriptionType()) {
     case QueryDescriptionType::GroupByPerfectHash:
     case QueryDescriptionType::NonGroupedAggregate: {
       reduceOneEntryNoCollisions(reduction_code);
       reduceOneEntryNoCollisionsIdx(reduction_code);
       break;
     }
     case QueryDescriptionType::GroupByBaselineHash: {
       reduceOneEntryBaseline(reduction_code);
       reduceOneEntryBaselineIdx(reduction_code);
       break;
     }
     default: {
       LOG(FATAL) << "Unexpected query description type";
     }
   }
   reduceLoop(reduction_code);
   // For small result sets, avoid native code generation and use the interpreter instead.
   if (query_mem_desc_.getEntryCount() < INTERP_THRESHOLD &&
       (!query_mem_desc_.getExecutor() || query_mem_desc_.blocksShareMemory())) {
     return reduction_code;
   }
   auto executor = Executor::getExecutor(executor_id_);
   CodeCacheKey key{cacheKey()};
   std::lock_guard<std::mutex> compilation_lock(executor->compilation_mutex_);
   const auto compilation_context =
       QueryEngine::getInstance()->s_code_accessor->get_or_wait(key);
   if (compilation_context) {
     reduction_code.func_ptr =
         reinterpret_cast<ReductionCode::FuncPtr>(compilation_context->get()->func());
     return reduction_code;
   }
   auto cgen_state_ = std::unique_ptr<CgenState>(new CgenState({}, false, executor.get()));
   auto cgen_state = reduction_code.cgen_state = cgen_state_.get();
   cgen_state->set_module_shallow_copy(executor->get_rt_module());
   reduction_code.module = cgen_state->module_;
 
   AUTOMATIC_IR_METADATA(cgen_state);
   auto ir_is_empty = create_llvm_function(reduction_code.ir_is_empty.get(), cgen_state);
   auto ir_reduce_one_entry =
       create_llvm_function(reduction_code.ir_reduce_one_entry.get(), cgen_state);
   auto ir_reduce_one_entry_idx =
       create_llvm_function(reduction_code.ir_reduce_one_entry_idx.get(), cgen_state);
   auto ir_reduce_loop =
       create_llvm_function(reduction_code.ir_reduce_loop.get(), cgen_state);
   std::unordered_map<const Function*, llvm::Function*> f;
   f.emplace(reduction_code.ir_is_empty.get(), ir_is_empty);
   f.emplace(reduction_code.ir_reduce_one_entry.get(), ir_reduce_one_entry);
   f.emplace(reduction_code.ir_reduce_one_entry_idx.get(), ir_reduce_one_entry_idx);
   f.emplace(reduction_code.ir_reduce_loop.get(), ir_reduce_loop);
   translate_function(reduction_code.ir_is_empty.get(), ir_is_empty, reduction_code, f);
   translate_function(
       reduction_code.ir_reduce_one_entry.get(), ir_reduce_one_entry, reduction_code, f);
   translate_function(reduction_code.ir_reduce_one_entry_idx.get(),
                      ir_reduce_one_entry_idx,
                      reduction_code,
                      f);
   translate_function(
       reduction_code.ir_reduce_loop.get(), ir_reduce_loop, reduction_code, f);
   reduction_code.llvm_reduce_loop = ir_reduce_loop;
   AUTOMATIC_IR_METADATA_DONE();
   reduction_code.cgen_state = nullptr;
   finalizeReductionCode(
       reduction_code, ir_is_empty, ir_reduce_one_entry, ir_reduce_one_entry_idx, key);
   return reduction_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::finalizeReductionCode	(	ReductionCode &	reduction_code,
		const llvm::Function *	ir_is_empty,
		const llvm::Function *	ir_reduce_one_entry,
		const llvm::Function *	ir_reduce_one_entry_idx,
		const CodeCacheKey &	key
	)		const

private

Definition at line 1257 of file ResultSetReductionJIT.cpp.

References CPU, CodeGenerator::generateNativeCPUCode(), logger::IR, ReductionCode::llvm_reduce_loop, LOG, ReductionCode::module, ReductionJIT, serialize_llvm_object(), and VLOG.

Referenced by codegen().

                                    {
   CompilationOptions co{
       ExecutorDeviceType::CPU, false, ExecutorOptLevel::ReductionJIT, false};
   VLOG(3) << "Reduction Loop:\n"
           << serialize_llvm_object(reduction_code.llvm_reduce_loop);
   VLOG(3) << "Reduction Is Empty Func:\n" << serialize_llvm_object(ir_is_empty);
   VLOG(3) << "Reduction One Entry Func:\n" << serialize_llvm_object(ir_reduce_one_entry);
   VLOG(3) << "Reduction One Entry Idx Func:\n"
           << serialize_llvm_object(ir_reduce_one_entry_idx);
 #ifdef NDEBUG
   LOG(IR) << "Reduction Loop:\n"
           << serialize_llvm_object(reduction_code.llvm_reduce_loop);
   LOG(IR) << "Reduction Is Empty Func:\n" << serialize_llvm_object(ir_is_empty);
   LOG(IR) << "Reduction One Entry Func:\n" << serialize_llvm_object(ir_reduce_one_entry);
   LOG(IR) << "Reduction One Entry Idx Func:\n"
           << serialize_llvm_object(ir_reduce_one_entry_idx);
 #else
   LOG(IR) << serialize_llvm_object(reduction_code.module);
 #endif
   auto ee = CodeGenerator::generateNativeCPUCode(
       reduction_code.llvm_reduce_loop, {reduction_code.llvm_reduce_loop}, co);
   auto cpu_compilation_context = std::make_shared<CpuCompilationContext>(std::move(ee));
   cpu_compilation_context->setFunctionPointer(reduction_code.llvm_reduce_loop);
   reduction_code.func_ptr =
       reinterpret_cast<ReductionCode::FuncPtr>(cpu_compilation_context->func());
   CHECK(reduction_code.llvm_reduce_loop->getParent() == reduction_code.module);
   auto executor = Executor::getExecutor(executor_id_);
   QueryEngine::getInstance()->s_code_accessor->reset(key,
                                                      std::move(cpu_compilation_context));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::isEmpty ( const ReductionCode & reduction_code ) const

protected

Definition at line 641 of file ResultSetReductionJIT.cpp.

References CHECK, CHECK_GE, CHECK_LT, QueryMemoryDescriptor::didOutputColumnar(), anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i32(), anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i64(), anonymous_namespace{ResultSetReductionJIT.cpp}::emit_read_int_from_buff(), EMPTY_KEY_32, EMPTY_KEY_64, ICmp::EQ, logger::FATAL, result_set::get_byteoff_of_slot(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getQueryDescriptionType(), QueryMemoryDescriptor::getTargetIdxForKey(), heavyai::GroupByPerfectHash, QueryMemoryDescriptor::hasKeylessHash(), Int32, Int64, ReductionCode::ir_is_empty, anonymous_namespace{ResultSetReductionJIT.cpp}::is_aggregate_query(), LOG, query_mem_desc_, and target_init_vals_.

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

                                                                              {
   auto ir_is_empty = reduction_code.ir_is_empty.get();
   CHECK(is_aggregate_query(query_mem_desc_.getQueryDescriptionType()));
   CHECK(!query_mem_desc_.didOutputColumnar());
   Value* key{nullptr};
   Value* empty_key_val{nullptr};
   const auto keys_ptr = ir_is_empty->arg(0);
   if (query_mem_desc_.hasKeylessHash()) {
     CHECK(query_mem_desc_.getQueryDescriptionType() ==
           QueryDescriptionType::GroupByPerfectHash);
     CHECK_GE(query_mem_desc_.getTargetIdxForKey(), 0);
     CHECK_LT(static_cast<size_t>(query_mem_desc_.getTargetIdxForKey()),
              target_init_vals_.size());
     const int64_t target_slot_off = result_set::get_byteoff_of_slot(
         query_mem_desc_.getTargetIdxForKey(), query_mem_desc_);
     const auto slot_ptr = ir_is_empty->add<GetElementPtr>(
         keys_ptr,
         ir_is_empty->addConstant<ConstantInt>(target_slot_off, Type::Int32),
         "is_empty_slot_ptr");
     const auto compact_sz =
         query_mem_desc_.getPaddedSlotWidthBytes(query_mem_desc_.getTargetIdxForKey());
     key = emit_read_int_from_buff(slot_ptr, compact_sz, ir_is_empty);
     empty_key_val = ir_is_empty->addConstant<ConstantInt>(
         target_init_vals_[query_mem_desc_.getTargetIdxForKey()], Type::Int64);
   } else {
     switch (query_mem_desc_.getEffectiveKeyWidth()) {
       case 4: {
         CHECK(QueryDescriptionType::GroupByPerfectHash !=
               query_mem_desc_.getQueryDescriptionType());
         key = emit_load_i32(keys_ptr, ir_is_empty);
         empty_key_val = ir_is_empty->addConstant<ConstantInt>(EMPTY_KEY_32, Type::Int32);
         break;
       }
       case 8: {
         key = emit_load_i64(keys_ptr, ir_is_empty);
         empty_key_val = ir_is_empty->addConstant<ConstantInt>(EMPTY_KEY_64, Type::Int64);
         break;
       }
       default:
         LOG(FATAL) << "Invalid key width";
     }
   }
   const auto ret =
       ir_is_empty->add<ICmp>(ICmp::Predicate::EQ, key, empty_key_val, "is_key_empty");
   ir_is_empty->add<Ret>(ret);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceLoop ( const ReductionCode & reduction_code ) const

protected

Definition at line 1033 of file ResultSetReductionJIT.cpp.

References anonymous_namespace{ResultSetReductionJIT.cpp}::generate_loop_body(), Int32, ReductionCode::ir_reduce_loop, and ReductionCode::ir_reduce_one_entry_idx.

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

                                                                                 {
   auto ir_reduce_loop = reduction_code.ir_reduce_loop.get();
   const auto this_buff_arg = ir_reduce_loop->arg(0);
   const auto that_buff_arg = ir_reduce_loop->arg(1);
   const auto start_index_arg = ir_reduce_loop->arg(2);
   const auto end_index_arg = ir_reduce_loop->arg(3);
   const auto that_entry_count_arg = ir_reduce_loop->arg(4);
   const auto this_qmd_handle_arg = ir_reduce_loop->arg(5);
   const auto that_qmd_handle_arg = ir_reduce_loop->arg(6);
   const auto serialized_varlen_buffer_arg = ir_reduce_loop->arg(7);
   For* for_loop =
       static_cast<For*>(ir_reduce_loop->add<For>(start_index_arg, end_index_arg, ""));
   generate_loop_body(for_loop,
                      ir_reduce_loop,
                      reduction_code.ir_reduce_one_entry_idx.get(),
                      this_buff_arg,
                      that_buff_arg,
                      start_index_arg,
                      that_entry_count_arg,
                      this_qmd_handle_arg,
                      that_qmd_handle_arg,
                      serialized_varlen_buffer_arg);
   ir_reduce_loop->add<Ret>(ir_reduce_loop->addConstant<ConstantInt>(0, Type::Int32));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneAggregateSlot	(	Value *	this_ptr1,
		Value *	this_ptr2,
		Value *	that_ptr1,
		Value *	that_ptr2,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	target_slot_idx,
		const int64_t	init_val,
		const int8_t	chosen_bytes,
		Function *	ir_reduce_one_entry
	)		const

private

Definition at line 1133 of file ResultSetReductionJIT.cpp.

References TargetInfo::agg_kind, CHECK_EQ, anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_count(), anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_nullable_value(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), is_distinct_target(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kAVG, kCOUNT, kCOUNT_IF, kMAX, kMIN, kMODE, kSUM, kSUM_IF, query_mem_desc_, reduceOneApproxQuantileSlot(), reduceOneCountDistinctSlot(), reduceOneModeSlot(), and UNREACHABLE.

Referenced by reduceOneSlot().

                                                                                         {
   auto agg_kind = target_info.agg_kind;
   switch (agg_kind) {
     case kCOUNT:
     case kCOUNT_IF:
     case kAPPROX_COUNT_DISTINCT:
       if (is_distinct_target(target_info)) {
         CHECK_EQ(static_cast<size_t>(chosen_bytes), sizeof(int64_t));
         reduceOneCountDistinctSlot(
             this_ptr1, that_ptr1, target_logical_idx, ir_reduce_one_entry);
         break;
       }
       CHECK_EQ(int64_t(0), init_val);
       emit_aggregate_one_count(this_ptr1, that_ptr1, chosen_bytes, ir_reduce_one_entry);
       break;
     case kAPPROX_QUANTILE:
       CHECK_EQ(sizeof(int64_t), static_cast<size_t>(chosen_bytes));
       reduceOneApproxQuantileSlot(
           this_ptr1, that_ptr1, target_logical_idx, ir_reduce_one_entry);
       break;
     case kMODE:
       reduceOneModeSlot(this_ptr1, that_ptr1, target_logical_idx, ir_reduce_one_entry);
       break;
     case kAVG:
       // Ignore float argument compaction for count component for fear of its overflow
       emit_aggregate_one_count(this_ptr2,
                                that_ptr2,
                                query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx),
                                ir_reduce_one_entry);
       agg_kind = kSUM;
     // fall thru
     case kSUM:
     case kMIN:
     case kMAX:
     // for conditional aggregation, we already "conditionally" aggregate value for each
     // resultset, so reduction just can use the non-conditional aggregation logic
     case kSUM_IF:
       emit_aggregate_one_nullable_value(agg_kind,
                                         this_ptr1,
                                         that_ptr1,
                                         init_val,
                                         chosen_bytes,
                                         target_info,
                                         ir_reduce_one_entry);
       break;
     default:
       UNREACHABLE() << "Invalid aggregate type: " << agg_kind;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneApproxQuantileSlot	(	Value *	this_ptr1,
		Value *	that_ptr1,
		const size_t	target_logical_idx,
		Function *	ir_reduce_one_entry
	)		const

private

Definition at line 1214 of file ResultSetReductionJIT.cpp.

References CHECK_LT, anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i64(), QueryMemoryDescriptor::getCountDistinctDescriptorsSize(), Int64, query_mem_desc_, and Void.

Referenced by reduceOneAggregateSlot().

                                          {
   CHECK_LT(target_logical_idx, query_mem_desc_.getCountDistinctDescriptorsSize());
   const auto old_set_handle = emit_load_i64(this_ptr1, ir_reduce_one_entry);
   const auto new_set_handle = emit_load_i64(that_ptr1, ir_reduce_one_entry);
   const auto this_qmd_arg = ir_reduce_one_entry->arg(2);
   const auto that_qmd_arg = ir_reduce_one_entry->arg(3);
   ir_reduce_one_entry->add<ExternalCall>(
       "approx_quantile_jit_rt",
       Type::Void,
       std::vector<const Value*>{
           new_set_handle,
           old_set_handle,
           that_qmd_arg,
           this_qmd_arg,
           ir_reduce_one_entry->addConstant<ConstantInt>(target_logical_idx, Type::Int64)},
       "");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneCountDistinctSlot	(	Value *	this_ptr1,
		Value *	that_ptr1,
		const size_t	target_logical_idx,
		Function *	ir_reduce_one_entry
	)		const

private

Definition at line 1192 of file ResultSetReductionJIT.cpp.

References CHECK_LT, anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i64(), QueryMemoryDescriptor::getCountDistinctDescriptorsSize(), Int64, query_mem_desc_, and Void.

Referenced by reduceOneAggregateSlot().

                                          {
   CHECK_LT(target_logical_idx, query_mem_desc_.getCountDistinctDescriptorsSize());
   const auto old_set_handle = emit_load_i64(this_ptr1, ir_reduce_one_entry);
   const auto new_set_handle = emit_load_i64(that_ptr1, ir_reduce_one_entry);
   const auto this_qmd_arg = ir_reduce_one_entry->arg(2);
   const auto that_qmd_arg = ir_reduce_one_entry->arg(3);
   ir_reduce_one_entry->add<ExternalCall>(
       "count_distinct_set_union_jit_rt",
       Type::Void,
       std::vector<const Value*>{
           new_set_handle,
           old_set_handle,
           that_qmd_arg,
           this_qmd_arg,
           ir_reduce_one_entry->addConstant<ConstantInt>(target_logical_idx, Type::Int64)},
       "");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneEntryBaseline ( const ReductionCode & reduction_code ) const

private

Definition at line 803 of file ResultSetReductionJIT.cpp.

References advance_slot(), QueryMemoryDescriptor::getTargetGroupbyIndex(), Int32, ReductionCode::ir_reduce_one_entry, kAVG, kSAMPLE, query_mem_desc_, reduceOneSlot(), QueryMemoryDescriptor::targetGroupbyIndicesSize(), targets_, and to_string().

Referenced by codegen().

                                                {
   auto ir_reduce_one_entry = reduction_code.ir_reduce_one_entry.get();
   const auto this_targets_ptr_arg = ir_reduce_one_entry->arg(0);
   const auto that_targets_ptr_arg = ir_reduce_one_entry->arg(1);
   Value* this_ptr1 = this_targets_ptr_arg;
   Value* that_ptr1 = that_targets_ptr_arg;
   size_t j = 0;
   size_t init_agg_val_idx = 0;
   for (size_t target_logical_idx = 0; target_logical_idx < targets_.size();
        ++target_logical_idx) {
     const auto& target_info = targets_[target_logical_idx];
     Value* this_ptr2{nullptr};
     Value* that_ptr2{nullptr};
     if (target_info.is_agg &&
         (target_info.agg_kind == kAVG ||
          (target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen()))) {
       const auto desc = "target_" + std::to_string(target_logical_idx) + "_second_slot";
       const auto second_slot_rel_off =
           ir_reduce_one_entry->addConstant<ConstantInt>(sizeof(int64_t), Type::Int32);
       this_ptr2 = ir_reduce_one_entry->add<GetElementPtr>(
           this_ptr1, second_slot_rel_off, "this_" + desc);
       that_ptr2 = ir_reduce_one_entry->add<GetElementPtr>(
           that_ptr1, second_slot_rel_off, "that_" + desc);
     }
     reduceOneSlot(this_ptr1,
                   this_ptr2,
                   that_ptr1,
                   that_ptr2,
                   target_info,
                   target_logical_idx,
                   j,
                   init_agg_val_idx,
                   j,
                   ir_reduce_one_entry);
     if (target_logical_idx + 1 == targets_.size()) {
       break;
     }
     if (query_mem_desc_.targetGroupbyIndicesSize() == 0) {
       init_agg_val_idx = advance_slot(init_agg_val_idx, target_info, false);
     } else {
       if (query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) < 0) {
         init_agg_val_idx = advance_slot(init_agg_val_idx, target_info, false);
       }
     }
     j = advance_slot(j, target_info, false);
     const auto next_desc =
         "target_" + std::to_string(target_logical_idx + 1) + "_first_slot";
     auto next_slot_rel_off = ir_reduce_one_entry->addConstant<ConstantInt>(
         init_agg_val_idx * sizeof(int64_t), Type::Int32);
     this_ptr1 = ir_reduce_one_entry->add<GetElementPtr>(
         this_targets_ptr_arg, next_slot_rel_off, next_desc);
     that_ptr1 = ir_reduce_one_entry->add<GetElementPtr>(
         that_targets_ptr_arg, next_slot_rel_off, next_desc);
   }
   ir_reduce_one_entry->add<Ret>(
       ir_reduce_one_entry->addConstant<ConstantInt>(0, Type::Int32));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneEntryBaselineIdx ( const ReductionCode & reduction_code ) const

private

Definition at line 896 of file ResultSetReductionJIT.cpp.

References Cast::BitCast, CHECK, QueryMemoryDescriptor::didOutputColumnar(), get_row_bytes(), get_slot_off_quad(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByBaselineHash, QueryMemoryDescriptor::hasKeylessHash(), Int1, Int32, Int64, Int64Ptr, Int8, Int8Ptr, ReductionCode::ir_is_empty, ReductionCode::ir_reduce_one_entry, ReductionCode::ir_reduce_one_entry_idx, BinaryOperator::Mul, query_mem_desc_, Cast::SExt, Cast::Trunc, and Void.

Referenced by codegen().

                                                {
   auto ir_reduce_one_entry_idx = reduction_code.ir_reduce_one_entry_idx.get();
   CHECK(query_mem_desc_.getQueryDescriptionType() ==
         QueryDescriptionType::GroupByBaselineHash);
   CHECK(!query_mem_desc_.hasKeylessHash());
   CHECK(!query_mem_desc_.didOutputColumnar());
   const auto this_buff = ir_reduce_one_entry_idx->arg(0);
   const auto that_buff = ir_reduce_one_entry_idx->arg(1);
   const auto that_entry_idx = ir_reduce_one_entry_idx->arg(2);
   const auto that_entry_count = ir_reduce_one_entry_idx->arg(3);
   const auto this_qmd_handle = ir_reduce_one_entry_idx->arg(4);
   const auto that_qmd_handle = ir_reduce_one_entry_idx->arg(5);
   const auto serialized_varlen_buffer_arg = ir_reduce_one_entry_idx->arg(6);
   const auto row_bytes = ir_reduce_one_entry_idx->addConstant<ConstantInt>(
       get_row_bytes(query_mem_desc_), Type::Int64);
   const auto that_entry_idx_64 = ir_reduce_one_entry_idx->add<Cast>(
       Cast::CastOp::SExt, that_entry_idx, Type::Int64, "that_entry_idx_64");
   const auto that_row_off_in_bytes =
       ir_reduce_one_entry_idx->add<BinaryOperator>(BinaryOperator::BinaryOp::Mul,
                                                    that_entry_idx_64,
                                                    row_bytes,
                                                    "that_row_off_in_bytes");
   const auto that_row_ptr = ir_reduce_one_entry_idx->add<GetElementPtr>(
       that_buff, that_row_off_in_bytes, "that_row_ptr");
   const auto that_is_empty =
       ir_reduce_one_entry_idx->add<Call>(reduction_code.ir_is_empty.get(),
                                          std::vector<const Value*>{that_row_ptr},
                                          "that_is_empty");
   ir_reduce_one_entry_idx->add<ReturnEarly>(
       that_is_empty,
       ir_reduce_one_entry_idx->addConstant<ConstantInt>(0, Type::Int32),
       "");
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   const auto one_element =
       ir_reduce_one_entry_idx->addConstant<ConstantInt>(1, Type::Int32);
   const auto this_targets_ptr_i64_ptr = ir_reduce_one_entry_idx->add<Alloca>(
       Type::Int64Ptr, one_element, "this_targets_ptr_out");
   const auto this_is_empty_ptr =
       ir_reduce_one_entry_idx->add<Alloca>(Type::Int8, one_element, "this_is_empty_out");
   ir_reduce_one_entry_idx->add<ExternalCall>(
       "get_group_value_reduction_rt",
       Type::Void,
       std::vector<const Value*>{
           this_buff,
           that_row_ptr,
           ir_reduce_one_entry_idx->addConstant<ConstantInt>(key_count, Type::Int32),
           this_qmd_handle,
           that_buff,
           that_entry_idx,
           that_entry_count,
           row_bytes,
           this_targets_ptr_i64_ptr,
           this_is_empty_ptr},
       "");
   const auto this_targets_ptr_i64 = ir_reduce_one_entry_idx->add<Load>(
       this_targets_ptr_i64_ptr, "this_targets_ptr_i64");
   auto this_is_empty =
       ir_reduce_one_entry_idx->add<Load>(this_is_empty_ptr, "this_is_empty");
   this_is_empty = ir_reduce_one_entry_idx->add<Cast>(
       Cast::CastOp::Trunc, this_is_empty, Type::Int1, "this_is_empty_bool");
   ir_reduce_one_entry_idx->add<ReturnEarly>(
       this_is_empty,
       ir_reduce_one_entry_idx->addConstant<ConstantInt>(0, Type::Int32),
       "");
   const auto key_qw_count = get_slot_off_quad(query_mem_desc_);
   const auto this_targets_ptr = ir_reduce_one_entry_idx->add<Cast>(
       Cast::CastOp::BitCast, this_targets_ptr_i64, Type::Int8Ptr, "this_targets_ptr");
   const auto key_byte_count = key_qw_count * sizeof(int64_t);
   const auto key_byte_count_lv =
       ir_reduce_one_entry_idx->addConstant<ConstantInt>(key_byte_count, Type::Int32);
   const auto that_targets_ptr = ir_reduce_one_entry_idx->add<GetElementPtr>(
       that_row_ptr, key_byte_count_lv, "that_targets_ptr");
   const auto reduce_rc = ir_reduce_one_entry_idx->add<Call>(
       reduction_code.ir_reduce_one_entry.get(),
       std::vector<const Value*>{this_targets_ptr,
                                 that_targets_ptr,
                                 this_qmd_handle,
                                 that_qmd_handle,
                                 serialized_varlen_buffer_arg},
       "");
   ir_reduce_one_entry_idx->add<Ret>(reduce_rc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneEntryNoCollisions ( const ReductionCode & reduction_code ) const

protected

Definition at line 688 of file ResultSetReductionJIT.cpp.

References align_to_int64(), get_key_bytes_rowwise(), Int32, ReductionCode::ir_is_empty, ReductionCode::ir_reduce_one_entry, query_mem_desc_, and reduceOneEntryTargetsNoCollisions().

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

                                                {
   auto ir_reduce_one_entry = reduction_code.ir_reduce_one_entry.get();
   const auto this_row_ptr = ir_reduce_one_entry->arg(0);
   const auto that_row_ptr = ir_reduce_one_entry->arg(1);
   const auto that_is_empty =
       ir_reduce_one_entry->add<Call>(reduction_code.ir_is_empty.get(),
                                      std::vector<const Value*>{that_row_ptr},
                                      "that_is_empty");
   ir_reduce_one_entry->add<ReturnEarly>(
       that_is_empty, ir_reduce_one_entry->addConstant<ConstantInt>(0, Type::Int32), "");
 
   const auto key_bytes = get_key_bytes_rowwise(query_mem_desc_);
   if (key_bytes) {  // copy the key from right hand side
     ir_reduce_one_entry->add<MemCpy>(
         this_row_ptr,
         that_row_ptr,
         ir_reduce_one_entry->addConstant<ConstantInt>(key_bytes, Type::Int32));
   }
 
   const auto key_bytes_with_padding = align_to_int64(key_bytes);
   const auto key_bytes_lv =
       ir_reduce_one_entry->addConstant<ConstantInt>(key_bytes_with_padding, Type::Int32);
   const auto this_targets_start_ptr = ir_reduce_one_entry->add<GetElementPtr>(
       this_row_ptr, key_bytes_lv, "this_targets_start");
   const auto that_targets_start_ptr = ir_reduce_one_entry->add<GetElementPtr>(
       that_row_ptr, key_bytes_lv, "that_targets_start");
 
   reduceOneEntryTargetsNoCollisions(
       ir_reduce_one_entry, this_targets_start_ptr, that_targets_start_ptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneEntryNoCollisionsIdx ( const ReductionCode & reduction_code ) const

protected

Definition at line 862 of file ResultSetReductionJIT.cpp.

References CHECK, get_row_bytes(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByPerfectHash, Int64, ReductionCode::ir_reduce_one_entry, ReductionCode::ir_reduce_one_entry_idx, BinaryOperator::Mul, heavyai::NonGroupedAggregate, query_mem_desc_, and Cast::SExt.

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

                                                {
   auto ir_reduce_one_entry_idx = reduction_code.ir_reduce_one_entry_idx.get();
   CHECK(query_mem_desc_.getQueryDescriptionType() ==
             QueryDescriptionType::GroupByPerfectHash ||
         query_mem_desc_.getQueryDescriptionType() ==
             QueryDescriptionType::NonGroupedAggregate);
   const auto this_buff = ir_reduce_one_entry_idx->arg(0);
   const auto that_buff = ir_reduce_one_entry_idx->arg(1);
   const auto entry_idx = ir_reduce_one_entry_idx->arg(2);
   const auto this_qmd_handle = ir_reduce_one_entry_idx->arg(4);
   const auto that_qmd_handle = ir_reduce_one_entry_idx->arg(5);
   const auto serialized_varlen_buffer_arg = ir_reduce_one_entry_idx->arg(6);
   const auto row_bytes = ir_reduce_one_entry_idx->addConstant<ConstantInt>(
       get_row_bytes(query_mem_desc_), Type::Int64);
   const auto entry_idx_64 = ir_reduce_one_entry_idx->add<Cast>(
       Cast::CastOp::SExt, entry_idx, Type::Int64, "entry_idx_64");
   const auto row_off_in_bytes = ir_reduce_one_entry_idx->add<BinaryOperator>(
       BinaryOperator::BinaryOp::Mul, entry_idx_64, row_bytes, "row_off_in_bytes");
   const auto this_row_ptr = ir_reduce_one_entry_idx->add<GetElementPtr>(
       this_buff, row_off_in_bytes, "this_row_ptr");
   const auto that_row_ptr = ir_reduce_one_entry_idx->add<GetElementPtr>(
       that_buff, row_off_in_bytes, "that_row_ptr");
   const auto reduce_rc = ir_reduce_one_entry_idx->add<Call>(
       reduction_code.ir_reduce_one_entry.get(),
       std::vector<const Value*>{this_row_ptr,
                                 that_row_ptr,
                                 this_qmd_handle,
                                 that_qmd_handle,
                                 serialized_varlen_buffer_arg},
       "");
   ir_reduce_one_entry_idx->add<Ret>(reduce_rc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneEntryTargetsNoCollisions	(	Function *	ir_reduce_one_entry,
		Value *	this_targets_start_ptr,
		Value *	that_targets_start_ptr
	)		const

private

Definition at line 720 of file ResultSetReductionJIT.cpp.

References QueryMemoryDescriptor::getColSlotContext(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getTargetGroupbyIndex(), Int32, kAVG, kSAMPLE, query_mem_desc_, reduceOneSlot(), QueryMemoryDescriptor::targetGroupbyIndicesSize(), targets_, to_string(), and UNLIKELY.

Referenced by reduceOneEntryNoCollisions().

                                          {
   const auto& col_slot_context = query_mem_desc_.getColSlotContext();
   Value* this_targets_ptr = this_targets_start_ptr;
   Value* that_targets_ptr = that_targets_start_ptr;
   size_t init_agg_val_idx = 0;
   for (size_t target_logical_idx = 0; target_logical_idx < targets_.size();
        ++target_logical_idx) {
     const auto& target_info = targets_[target_logical_idx];
     const auto& slots_for_col = col_slot_context.getSlotsForCol(target_logical_idx);
     Value* this_ptr2{nullptr};
     Value* that_ptr2{nullptr};
 
     bool two_slot_target{false};
     if (target_info.is_agg &&
         (target_info.agg_kind == kAVG ||
          (target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen()))) {
       // Note that this assumes if one of the slot pairs in a given target is an array,
       // all slot pairs are arrays. Currently this is true for all geo targets, but we
       // should better codify and store this information in the future
       two_slot_target = true;
     }
 
     for (size_t target_slot_idx = slots_for_col.front();
          target_slot_idx < slots_for_col.back() + 1;
          target_slot_idx += 2) {
       const auto slot_off_val = query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx);
       const auto slot_off =
           ir_reduce_one_entry->addConstant<ConstantInt>(slot_off_val, Type::Int32);
       if (UNLIKELY(two_slot_target)) {
         const auto desc = "target_" + std::to_string(target_logical_idx) + "_second_slot";
         this_ptr2 = ir_reduce_one_entry->add<GetElementPtr>(
             this_targets_ptr, slot_off, "this_" + desc);
         that_ptr2 = ir_reduce_one_entry->add<GetElementPtr>(
             that_targets_ptr, slot_off, "that_" + desc);
       }
       reduceOneSlot(this_targets_ptr,
                     this_ptr2,
                     that_targets_ptr,
                     that_ptr2,
                     target_info,
                     target_logical_idx,
                     target_slot_idx,
                     init_agg_val_idx,
                     slots_for_col.front(),
                     ir_reduce_one_entry);
       auto increment_agg_val_idx_maybe =
           [&init_agg_val_idx, &target_logical_idx, this](const int slot_count) {
             if (query_mem_desc_.targetGroupbyIndicesSize() == 0 ||
                 query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) < 0) {
               init_agg_val_idx += slot_count;
             }
           };
       if (target_logical_idx + 1 == targets_.size() &&
           target_slot_idx + 1 >= slots_for_col.back()) {
         break;
       }
       const auto next_desc =
           "target_" + std::to_string(target_logical_idx + 1) + "_first_slot";
       if (UNLIKELY(two_slot_target)) {
         increment_agg_val_idx_maybe(2);
         const auto two_slot_off = ir_reduce_one_entry->addConstant<ConstantInt>(
             slot_off_val + query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx + 1),
             Type::Int32);
         this_targets_ptr = ir_reduce_one_entry->add<GetElementPtr>(
             this_targets_ptr, two_slot_off, "this_" + next_desc);
         that_targets_ptr = ir_reduce_one_entry->add<GetElementPtr>(
             that_targets_ptr, two_slot_off, "that_" + next_desc);
       } else {
         increment_agg_val_idx_maybe(1);
         this_targets_ptr = ir_reduce_one_entry->add<GetElementPtr>(
             this_targets_ptr, slot_off, "this_" + next_desc);
         that_targets_ptr = ir_reduce_one_entry->add<GetElementPtr>(
             that_targets_ptr, slot_off, "that_" + next_desc);
       }
     }
   }
   ir_reduce_one_entry->add<Ret>(
       ir_reduce_one_entry->addConstant<ConstantInt>(0, Type::Int32));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneModeSlot	(	Value *	this_ptr1,
		Value *	that_ptr1,
		const size_t	target_logical_idx,
		Function *	ir_reduce_one_entry
	)		const

private

Definition at line 1236 of file ResultSetReductionJIT.cpp.

References CHECK_LT, anonymous_namespace{ResultSetReductionJIT.cpp}::emit_load_i64(), QueryMemoryDescriptor::getCountDistinctDescriptorsSize(), Int64, query_mem_desc_, and Void.

Referenced by reduceOneAggregateSlot().

                                                                                    {
   CHECK_LT(target_logical_idx, query_mem_desc_.getCountDistinctDescriptorsSize());
   const auto old_set_handle = emit_load_i64(this_ptr1, ir_reduce_one_entry);
   const auto new_set_handle = emit_load_i64(that_ptr1, ir_reduce_one_entry);
   const auto this_qmd_arg = ir_reduce_one_entry->arg(2);
   const auto that_qmd_arg = ir_reduce_one_entry->arg(3);
   ir_reduce_one_entry->add<ExternalCall>(
       "mode_jit_rt",
       Type::Void,
       std::vector<const Value*>{
           new_set_handle,
           old_set_handle,
           that_qmd_arg,
           this_qmd_arg,
           ir_reduce_one_entry->addConstant<ConstantInt>(target_logical_idx, Type::Int64)},
       "");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetReductionJIT::reduceOneSlot	(	Value *	this_ptr1,
		Value *	this_ptr2,
		Value *	that_ptr1,
		Value *	that_ptr2,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	target_slot_idx,
		const size_t	init_agg_val_idx,
		const size_t	first_slot_idx_for_target,
		Function *	ir_reduce_one_entry
	)		const

private

Definition at line 1058 of file ResultSetReductionJIT.cpp.

References TargetInfo::agg_kind, CHECK, CHECK_LT, anonymous_namespace{ResultSetReductionJIT.cpp}::emit_checked_write_projection(), anonymous_namespace{ResultSetReductionJIT.cpp}::emit_write_projection(), SQLTypeInfo::get_elem_type(), result_set::get_width_for_slot(), QueryMemoryDescriptor::getTargetGroupbyIndex(), Int32, Int64, TargetInfo::is_agg, SQLTypeInfo::is_geometry(), SQLTypeInfo::is_string(), SQLTypeInfo::is_varlen(), kSAMPLE, kSINGLE_VALUE, ICmp::NE, query_mem_desc_, reduceOneAggregateSlot(), TargetInfo::sql_type, takes_float_argument(), target_init_vals_, QueryMemoryDescriptor::targetGroupbyIndicesSize(), and Void.

Referenced by reduceOneEntryBaseline(), and reduceOneEntryTargetsNoCollisions().

                                                                                {
   if (query_mem_desc_.targetGroupbyIndicesSize() > 0) {
     if (query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) >= 0) {
       return;
     }
   }
   const bool float_argument_input = takes_float_argument(target_info);
   const auto chosen_bytes = result_set::get_width_for_slot(
       target_slot_idx, float_argument_input, query_mem_desc_);
   CHECK_LT(init_agg_val_idx, target_init_vals_.size());
   auto init_val = target_init_vals_[init_agg_val_idx];
   if (target_info.is_agg &&
       (target_info.agg_kind != kSINGLE_VALUE && target_info.agg_kind != kSAMPLE)) {
     reduceOneAggregateSlot(this_ptr1,
                            this_ptr2,
                            that_ptr1,
                            that_ptr2,
                            target_info,
                            target_logical_idx,
                            target_slot_idx,
                            init_val,
                            chosen_bytes,
                            ir_reduce_one_entry);
   } else if (target_info.agg_kind == kSINGLE_VALUE) {
     const auto checked_rc = emit_checked_write_projection(
         this_ptr1, that_ptr1, init_val, chosen_bytes, ir_reduce_one_entry);
 
     auto checked_rc_bool = ir_reduce_one_entry->add<ICmp>(
         ICmp::Predicate::NE,
         checked_rc,
         ir_reduce_one_entry->addConstant<ConstantInt>(0, Type::Int32),
         "");
 
     ir_reduce_one_entry->add<ReturnEarly>(checked_rc_bool, checked_rc, "");
 
   } else {
     emit_write_projection(
         this_ptr1, that_ptr1, init_val, chosen_bytes, ir_reduce_one_entry);
     if (target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen()) {
       CHECK(this_ptr2 && that_ptr2);
       size_t length_to_elems{0};
       if (target_info.sql_type.is_geometry()) {
         // TODO: Assumes hard-coded sizes for geometry targets
         length_to_elems = target_slot_idx == first_slot_idx_for_target ? 1 : 4;
       } else {
         const auto& elem_ti = target_info.sql_type.get_elem_type();
         length_to_elems = target_info.sql_type.is_string() ? 1 : elem_ti.get_size();
       }
       const auto serialized_varlen_buffer_arg = ir_reduce_one_entry->arg(4);
       ir_reduce_one_entry->add<ExternalCall>(
           "serialized_varlen_buffer_sample",
           Type::Void,
           std::vector<const Value*>{
               serialized_varlen_buffer_arg,
               this_ptr1,
               this_ptr2,
               that_ptr1,
               that_ptr2,
               ir_reduce_one_entry->addConstant<ConstantInt>(init_val, Type::Int64),
               ir_reduce_one_entry->addConstant<ConstantInt>(length_to_elems,
                                                             Type::Int64)},
           "");
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

size_t ResultSetReductionJIT::executor_id_

protected

Definition at line 78 of file ResultSetReductionJIT.h.

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

const QueryMemoryDescriptor ResultSetReductionJIT::query_mem_desc_

private

Definition at line 140 of file ResultSetReductionJIT.h.

Referenced by cacheKey(), codegen(), GpuReductionHelperJIT::codegen(), isEmpty(), reduceOneAggregateSlot(), reduceOneApproxQuantileSlot(), reduceOneCountDistinctSlot(), reduceOneEntryBaseline(), reduceOneEntryBaselineIdx(), reduceOneEntryNoCollisions(), reduceOneEntryNoCollisionsIdx(), reduceOneEntryTargetsNoCollisions(), reduceOneModeSlot(), and reduceOneSlot().

const std::vector<int64_t> ResultSetReductionJIT::target_init_vals_

private

Definition at line 142 of file ResultSetReductionJIT.h.

Referenced by cacheKey(), isEmpty(), and reduceOneSlot().

const std::vector<TargetInfo> ResultSetReductionJIT::targets_

private

Definition at line 141 of file ResultSetReductionJIT.h.

Referenced by cacheKey(), reduceOneEntryBaseline(), and reduceOneEntryTargetsNoCollisions().

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation