TreeModelPredictionMgr Class Reference

#include <TreeModelPredictionMgr.h>

Collaboration diagram for TreeModelPredictionMgr:

Public Member Functions
	TreeModelPredictionMgr (const Data_Namespace::MemoryLevel memory_level, Executor *executor, const std::vector< std::vector< DecisionTreeEntry >> &decision_trees, const std::vector< int64_t > &decision_tree_offsets, const bool compute_avg)
	~TreeModelPredictionMgr ()
llvm::Value *	codegen (const std::vector< llvm::Value * > &regressor_inputs, const CompilationOptions &co) const

Private Member Functions
void	allocateAndPopulateHostBuffers (const std::vector< std::vector< DecisionTreeEntry >> &decision_trees, const std::vector< int64_t > &decision_tree_offsets)
void	createKernelBuffers ()

Private Attributes
const Data_Namespace::MemoryLevel	memory_level_
Executor *	executor_
Data_Namespace::DataMgr *	data_mgr_
const int	device_count_
const int32_t	num_trees_
const bool	compute_avg_
int8_t *	host_decision_tree_table_
int8_t *	host_decision_tree_offsets_
int64_t	decision_tree_table_size_bytes_
int64_t	decision_tree_offsets_size_bytes_
std::vector < Data_Namespace::AbstractBuffer * >	decision_tree_table_device_buffers_
std::vector < Data_Namespace::AbstractBuffer * >	decision_tree_offsets_device_buffers_
std::vector< const int8_t * >	kernel_decision_tree_tables_
std::vector< const int8_t * >	kernel_decision_tree_offsets_

Detailed Description

Definition at line 37 of file TreeModelPredictionMgr.h.

Constructor & Destructor Documentation

TreeModelPredictionMgr::TreeModelPredictionMgr	(	const Data_Namespace::MemoryLevel	memory_level,
		Executor *	executor,
		const std::vector< std::vector< DecisionTreeEntry >> &	decision_trees,
		const std::vector< int64_t > &	decision_tree_offsets,
		const bool	compute_avg
	)

Definition at line 28 of file TreeModelPredictionMgr.cpp.

References allocateAndPopulateHostBuffers(), CHECK, CHECK_EQ, Data_Namespace::CPU_LEVEL, createKernelBuffers(), Data_Namespace::GPU_LEVEL, and memory_level_.

    : memory_level_(memory_level)
    , executor_(executor)
    , data_mgr_(executor->getDataMgr())
    , device_count_(executor->deviceCount(memory_level == Data_Namespace::GPU_LEVEL
                                              ? ExecutorDeviceType::GPU
                                              : ExecutorDeviceType::CPU))
    , num_trees_(decision_trees.size())
    , compute_avg_(compute_avg) {
#ifdef HAVE_CUDA
  CHECK(memory_level_ == Data_Namespace::CPU_LEVEL ||
        memory_level_ == Data_Namespace::GPU_LEVEL);
#else
  CHECK_EQ(Data_Namespace::CPU_LEVEL, memory_level_);
#endif  // HAVE_CUDA
  allocateAndPopulateHostBuffers(decision_trees, decision_tree_offsets);
  createKernelBuffers();
}

Here is the call graph for this function:

TreeModelPredictionMgr::~TreeModelPredictionMgr

(

)

Definition at line 52 of file TreeModelPredictionMgr.cpp.

References CHECK, data_mgr_, decision_tree_offsets_device_buffers_, decision_tree_table_device_buffers_, and Data_Namespace::DataMgr::free().

                                                {
  CHECK(data_mgr_);
  for (auto* buffer : decision_tree_table_device_buffers_) {
    CHECK(buffer);
    data_mgr_->free(buffer);
  }
  for (auto* buffer : decision_tree_offsets_device_buffers_) {
    CHECK(buffer);
    data_mgr_->free(buffer);
  }
}

Here is the call graph for this function:

Member Function Documentation

void TreeModelPredictionMgr::allocateAndPopulateHostBuffers ( const std::vector< std::vector< DecisionTreeEntry >> &  decision_trees, const std::vector< int64_t > &  decision_tree_offsets  )

private

Definition at line 64 of file TreeModelPredictionMgr.cpp.

References CHECK_EQ, DEBUG_TIMER, decision_tree_offsets_size_bytes_, decision_tree_table_size_bytes_, executor_, host_decision_tree_offsets_, host_decision_tree_table_, num_trees_, and threading_serial::parallel_for().

Referenced by TreeModelPredictionMgr().

                                                     {
  auto timer = DEBUG_TIMER(__func__);
  const size_t num_trees = decision_trees.size();
  CHECK_EQ(num_trees, static_cast<size_t>(num_trees_));
  CHECK_EQ(num_trees, decision_tree_offsets.size() - 1);
  const size_t num_tree_entries = decision_tree_offsets[num_trees];
  decision_tree_table_size_bytes_ = num_tree_entries * sizeof(DecisionTreeEntry);
  decision_tree_offsets_size_bytes_ = decision_tree_offsets.size() * sizeof(size_t);
  host_decision_tree_table_ =
      executor_->getRowSetMemoryOwner()->allocate(decision_tree_table_size_bytes_);
  host_decision_tree_offsets_ =
      executor_->getRowSetMemoryOwner()->allocate(decision_tree_offsets_size_bytes_);
  // Take this opportunity to copy offsets buffer over
  std::memcpy(host_decision_tree_offsets_,
              reinterpret_cast<const int8_t*>(decision_tree_offsets.data()),
              decision_tree_offsets_size_bytes_);

  tbb::parallel_for(
      tbb::blocked_range<size_t>(0, num_trees), [&](const tbb::blocked_range<size_t>& r) {
        const auto start_tree_idx = r.begin();
        const auto end_tree_idx = r.end();
        for (size_t tree_idx = start_tree_idx; tree_idx < end_tree_idx; ++tree_idx) {
          std::memcpy(host_decision_tree_table_ +
                          decision_tree_offsets[tree_idx] * sizeof(DecisionTreeEntry),
                      reinterpret_cast<const int8_t*>(decision_trees[tree_idx].data()),
                      decision_trees[tree_idx].size() * sizeof(DecisionTreeEntry));
        }
      });
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * TreeModelPredictionMgr::codegen	(	const std::vector< llvm::Value * > &	regressor_inputs,
		const CompilationOptions &	co
	)		const

Definition at line 158 of file TreeModelPredictionMgr.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CodeGenerator::codegen(), CodeGenerator::codegenHoistedConstants(), compute_avg_, device_count_, CompilationOptions::device_type, executor_, generate_kernel_buffer_constants(), GPU, Data_Namespace::GPU_LEVEL, CompilationOptions::hoist_literals, inline_fp_null_value< double >(), kENCODING_NONE, kernel_decision_tree_offsets_, kernel_decision_tree_tables_, memory_level_, and num_trees_.

Referenced by CodeGenerator::codegenTreeRegPredict().

                                        {
  CHECK(kernel_decision_tree_tables_.size() == kernel_decision_tree_offsets_.size());
  CHECK(kernel_decision_tree_tables_.size() == static_cast<size_t>(device_count_));
  if (!co.hoist_literals && kernel_decision_tree_tables_.size() > 1UL) {
    CHECK(memory_level_ == Data_Namespace::GPU_LEVEL);
    CHECK(co.device_type == ExecutorDeviceType::GPU);
    throw QueryMustRunOnCpu();
  }
  CHECK(co.hoist_literals || kernel_decision_tree_tables_.size() == 1UL);

  auto cgen_state_ptr = executor_->getCgenStatePtr();
  AUTOMATIC_IR_METADATA(cgen_state_ptr);

  const auto [decision_tree_table_constants_owned, decision_tree_table_constants] =
      generate_kernel_buffer_constants(
          cgen_state_ptr, kernel_decision_tree_tables_, co.hoist_literals);

  const auto [decision_tree_offsets_constants_owned, decision_tree_offsets_constants] =
      generate_kernel_buffer_constants(
          cgen_state_ptr, kernel_decision_tree_offsets_, co.hoist_literals);

  CodeGenerator code_generator(executor_);

  const auto decision_tree_table_handle_lvs =
      co.hoist_literals
          ? code_generator.codegenHoistedConstants(
                decision_tree_table_constants, kENCODING_NONE, {})
          : code_generator.codegen(decision_tree_table_constants[0], false, co);

  const auto decision_tree_offsets_handle_lvs =
      co.hoist_literals
          ? code_generator.codegenHoistedConstants(
                decision_tree_offsets_constants, kENCODING_NONE, {})
          : code_generator.codegen(decision_tree_offsets_constants[0], false, co);

  auto& builder = cgen_state_ptr->ir_builder_;
  const int32_t num_regressors = static_cast<int32_t>(regressor_inputs.size());
  auto regressor_ty = llvm::Type::getDoubleTy(cgen_state_ptr->context_);
  llvm::ArrayType* regressor_arr_type =
      llvm::ArrayType::get(regressor_ty, num_regressors);
  auto regressor_local_storage_lv =
      builder.CreateAlloca(regressor_arr_type, nullptr, "Regressor_Local_Storage");
  auto idx_lv = cgen_state_ptr->llInt(0);
  auto regressor_local_storage_gep = llvm::GetElementPtrInst::CreateInBounds(
      regressor_local_storage_lv->getType()->getScalarType()->getPointerElementType(),
      regressor_local_storage_lv,
      {idx_lv, idx_lv},
      "",
      builder.GetInsertBlock());
  for (int32_t reg_idx = 0; reg_idx < num_regressors; ++reg_idx) {
    auto reg_ptr = builder.CreateGEP(
        regressor_local_storage_lv->getType()->getScalarType()->getPointerElementType(),
        regressor_local_storage_lv,
        {cgen_state_ptr->llInt(0), cgen_state_ptr->llInt(reg_idx)},
        "");
    builder.CreateStore(regressor_inputs[reg_idx], reg_ptr);
  }
  const double translated_null_value = inline_fp_null_value<double>();

  return cgen_state_ptr->emitCall(
      "tree_model_reg_predict",
      {regressor_local_storage_gep,
       cgen_state_ptr->castToTypeIn(decision_tree_table_handle_lvs.front(), 64),
       cgen_state_ptr->castToTypeIn(decision_tree_offsets_handle_lvs.front(), 64),
       cgen_state_ptr->llInt(num_regressors),
       cgen_state_ptr->llInt(num_trees_),
       cgen_state_ptr->llBool(compute_avg_),
       cgen_state_ptr->llFp(translated_null_value)});
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TreeModelPredictionMgr::createKernelBuffers ( )

private

Definition at line 96 of file TreeModelPredictionMgr.cpp.

References CudaAllocator::allocGpuAbstractBuffer(), CHECK_EQ, copy_to_nvidia_gpu(), Data_Namespace::CPU_LEVEL, data_mgr_, DEBUG_TIMER, decision_tree_offsets_device_buffers_, decision_tree_offsets_size_bytes_, decision_tree_table_device_buffers_, decision_tree_table_size_bytes_, device_count_, Data_Namespace::GPU_LEVEL, host_decision_tree_offsets_, host_decision_tree_table_, kernel_decision_tree_offsets_, kernel_decision_tree_tables_, and memory_level_.

Referenced by TreeModelPredictionMgr().

                                                 {
  auto timer = DEBUG_TIMER(__func__);
#ifdef HAVE_CUDA
  if (memory_level_ == Data_Namespace::GPU_LEVEL) {
    for (int device_id = 0; device_id < device_count_; ++device_id) {
      decision_tree_table_device_buffers_.emplace_back(
          CudaAllocator::allocGpuAbstractBuffer(
              data_mgr_, decision_tree_table_size_bytes_, device_id));
      decision_tree_offsets_device_buffers_.emplace_back(
          CudaAllocator::allocGpuAbstractBuffer(
              data_mgr_, decision_tree_offsets_size_bytes_, device_id));
      auto decision_tree_table_device_buffer = reinterpret_cast<const int8_t*>(
          decision_tree_table_device_buffers_.back()->getMemoryPtr());
      auto decision_tree_offsets_device_buffer = reinterpret_cast<const int8_t*>(
          decision_tree_offsets_device_buffers_.back()->getMemoryPtr());
      copy_to_nvidia_gpu(data_mgr_,
                         reinterpret_cast<CUdeviceptr>(decision_tree_table_device_buffer),
                         reinterpret_cast<const int8_t*>(host_decision_tree_table_),
                         decision_tree_table_size_bytes_,
                         device_id);
      copy_to_nvidia_gpu(
          data_mgr_,
          reinterpret_cast<CUdeviceptr>(decision_tree_offsets_device_buffer),
          reinterpret_cast<const int8_t*>(host_decision_tree_offsets_),
          decision_tree_offsets_size_bytes_,
          device_id);
      kernel_decision_tree_tables_.push_back(decision_tree_table_device_buffer);
      kernel_decision_tree_offsets_.push_back(decision_tree_offsets_device_buffer);
    }
  }
#else
  CHECK_EQ(1, device_count_);
#endif
  if (memory_level_ == Data_Namespace::CPU_LEVEL) {
    kernel_decision_tree_tables_.push_back(host_decision_tree_table_);
    kernel_decision_tree_offsets_.push_back(host_decision_tree_offsets_);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const bool TreeModelPredictionMgr::compute_avg_

private

Definition at line 61 of file TreeModelPredictionMgr.h.

Referenced by codegen().

Data_Namespace::DataMgr* TreeModelPredictionMgr::data_mgr_

private

Definition at line 58 of file TreeModelPredictionMgr.h.

Referenced by createKernelBuffers(), and ~TreeModelPredictionMgr().

std::vector<Data_Namespace::AbstractBuffer*> TreeModelPredictionMgr::decision_tree_offsets_device_buffers_

private

Definition at line 67 of file TreeModelPredictionMgr.h.

Referenced by createKernelBuffers(), and ~TreeModelPredictionMgr().

int64_t TreeModelPredictionMgr::decision_tree_offsets_size_bytes_

private

Definition at line 65 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and createKernelBuffers().

std::vector<Data_Namespace::AbstractBuffer*> TreeModelPredictionMgr::decision_tree_table_device_buffers_

private

Definition at line 66 of file TreeModelPredictionMgr.h.

Referenced by createKernelBuffers(), and ~TreeModelPredictionMgr().

int64_t TreeModelPredictionMgr::decision_tree_table_size_bytes_

private

Definition at line 64 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and createKernelBuffers().

const int TreeModelPredictionMgr::device_count_

private

Definition at line 59 of file TreeModelPredictionMgr.h.

Referenced by codegen(), and createKernelBuffers().

Executor* TreeModelPredictionMgr::executor_

private

Definition at line 57 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and codegen().

int8_t* TreeModelPredictionMgr::host_decision_tree_offsets_

private

Definition at line 63 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and createKernelBuffers().

int8_t* TreeModelPredictionMgr::host_decision_tree_table_

private

Definition at line 62 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and createKernelBuffers().

std::vector<const int8_t*> TreeModelPredictionMgr::kernel_decision_tree_offsets_

private

Definition at line 69 of file TreeModelPredictionMgr.h.

Referenced by codegen(), and createKernelBuffers().

std::vector<const int8_t*> TreeModelPredictionMgr::kernel_decision_tree_tables_

private

Definition at line 68 of file TreeModelPredictionMgr.h.

Referenced by codegen(), and createKernelBuffers().

const Data_Namespace::MemoryLevel TreeModelPredictionMgr::memory_level_

private

Definition at line 56 of file TreeModelPredictionMgr.h.

Referenced by codegen(), createKernelBuffers(), and TreeModelPredictionMgr().

const int32_t TreeModelPredictionMgr::num_trees_

private

Definition at line 60 of file TreeModelPredictionMgr.h.

Referenced by allocateAndPopulateHostBuffers(), and codegen().

---

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

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