#include <InValuesBitmap.h>

Collaboration diagram for InValuesBitmap:

Classes
struct	BitIsSetParams

Public Member Functions
	InValuesBitmap (const std::vector< int64_t > &values, const int64_t null_val, const Data_Namespace::MemoryLevel memory_level, const int device_count, Data_Namespace::DataMgr *data_mgr, CompilationOptions const &co)

	~InValuesBitmap ()

llvm::Value *	codegen (llvm::Value needle, Executor executor) const

bool	isEmpty () const

bool	hasNull () const

size_t	gpuBuffers () const

BitIsSetParams	prepareBitIsSetParams (Executor *executor, std::vector< std::shared_ptr< const Analyzer::Constant >> const &constant_owned) const

Private Attributes
std::vector < Data_Namespace::AbstractBuffer * >	gpu_buffers_

std::vector< int8_t * >	bitsets_

bool	rhs_has_null_

int64_t	min_val_

int64_t	max_val_

const int64_t	null_val_

const Data_Namespace::MemoryLevel	memory_level_

const int	device_count_

Data_Namespace::DataMgr *	data_mgr_

CompilationOptions	co_

Detailed Description

Definition at line 42 of file InValuesBitmap.h.

Constructor & Destructor Documentation

InValuesBitmap::InValuesBitmap	(	const std::vector< int64_t > &	values,
		const int64_t	null_val,
		const Data_Namespace::MemoryLevel	memory_level,
		const int	device_count,
		Data_Namespace::DataMgr *	data_mgr,
		CompilationOptions const &	co
	)

Definition at line 35 of file InValuesBitmap.cpp.

References agg_count_distinct_bitmap(), Data_Namespace::DataMgr::alloc(), bitsets_, CHECK, CHECK_EQ, checked_calloc(), Data_Namespace::CPU_LEVEL, data_mgr_, device_count_, g_bitmap_memory_limit, getQueryEngineCudaStreamForDevice(), gpu_buffers_, Data_Namespace::GPU_LEVEL, max_val_, memory_level_, min_val_, and rhs_has_null_.

     : rhs_has_null_(false)
     , null_val_(null_val)
     , memory_level_(memory_level)
     , device_count_(device_count)
     , data_mgr_(data_mgr)
     , co_(co) {
 #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
   if (values.empty()) {
     return;
   }
   min_val_ = std::numeric_limits<int64_t>::max();
   max_val_ = std::numeric_limits<int64_t>::min();
   for (const auto value : values) {
     if (value == null_val) {
       rhs_has_null_ = true;
       continue;
     }
     if (value < min_val_) {
       min_val_ = value;
     }
     if (value > max_val_) {
       max_val_ = value;
     }
   }
   if (max_val_ < min_val_) {
     CHECK_EQ(std::numeric_limits<int64_t>::max(), min_val_);
     CHECK_EQ(std::numeric_limits<int64_t>::min(), max_val_);
     CHECK(rhs_has_null_);
     return;
   }
   uint64_t const bitmap_sz_bits_minus_one = max_val_ - min_val_;
   if (static_cast<uint64_t>(g_bitmap_memory_limit) <= bitmap_sz_bits_minus_one) {
     throw FailedToCreateBitmap();
   }
   // bitmap_sz_bytes = ceil(bitmap_sz_bits / 8.0) = (bitmap_sz_bits-1) / 8 + 1
   uint64_t const bitmap_sz_bytes = bitmap_sz_bits_minus_one / 8 + 1;
   auto cpu_bitset = static_cast<int8_t*>(checked_calloc(bitmap_sz_bytes, 1));
   for (const auto value : values) {
     if (value == null_val) {
       continue;
     }
     agg_count_distinct_bitmap(
         reinterpret_cast<int64_t*>(&cpu_bitset), value, min_val_, 0);
   }
 #ifdef HAVE_CUDA
   if (memory_level_ == Data_Namespace::GPU_LEVEL) {
     for (int device_id = 0; device_id < device_count_; ++device_id) {
       auto device_allocator = std::make_unique<CudaAllocator>(
           data_mgr_, device_id, getQueryEngineCudaStreamForDevice(device_id));
       gpu_buffers_.emplace_back(
           data_mgr->alloc(Data_Namespace::GPU_LEVEL, device_id, bitmap_sz_bytes));
       auto gpu_bitset = gpu_buffers_.back()->getMemoryPtr();
       device_allocator->copyToDevice(gpu_bitset, cpu_bitset, bitmap_sz_bytes);
       bitsets_.push_back(gpu_bitset);
     }
     free(cpu_bitset);
   } else {
     bitsets_.push_back(cpu_bitset);
   }
 #else
   CHECK_EQ(1, device_count_);
   bitsets_.push_back(cpu_bitset);
 #endif  // HAVE_CUDA
 }

Here is the call graph for this function:

InValuesBitmap::~InValuesBitmap ( )

Definition at line 111 of file InValuesBitmap.cpp.

References bitsets_, CHECK, CHECK_EQ, Data_Namespace::CPU_LEVEL, data_mgr_, Data_Namespace::DataMgr::free(), gpu_buffers_, and memory_level_.

                                 {
   if (bitsets_.empty()) {
     return;
   }
   if (memory_level_ == Data_Namespace::CPU_LEVEL) {
     CHECK_EQ(size_t(1), bitsets_.size());
     free(bitsets_.front());
   } else {
     CHECK(data_mgr_);
     for (auto& gpu_buffer : gpu_buffers_) {
       data_mgr_->free(gpu_buffer);
     }
   }
 }

Here is the call graph for this function:

Member Function Documentation

llvm::Value * InValuesBitmap::codegen	(	llvm::Value *	needle,
		Executor *	executor
	)		const

Definition at line 166 of file InValuesBitmap.cpp.

References Parser::IntLiteral::analyzeValue(), AUTOMATIC_IR_METADATA, bitsets_, CHECK, CHECK_EQ, inline_int_null_val(), kBOOLEAN, kENCODING_NONE, and prepareBitIsSetParams().

Referenced by CodeGenerator::codegen().

                                                                               {
   auto cgen_state = executor->getCgenStatePtr();
   AUTOMATIC_IR_METADATA(cgen_state);
   std::vector<std::shared_ptr<const Analyzer::Constant>> constants_owned;
   for (const auto bitset : bitsets_) {
     const int64_t bitset_handle = reinterpret_cast<int64_t>(bitset);
     const auto bitset_handle_literal = std::dynamic_pointer_cast<Analyzer::Constant>(
         Parser::IntLiteral::analyzeValue(bitset_handle));
     CHECK(bitset_handle_literal);
     CHECK_EQ(kENCODING_NONE, bitset_handle_literal->get_type_info().get_compression());
     constants_owned.push_back(bitset_handle_literal);
   }
   const auto needle_i64 = cgen_state->castToTypeIn(needle, 64);
   const auto null_bool_val =
       static_cast<int8_t>(inline_int_null_val(SQLTypeInfo(kBOOLEAN, false)));
   auto const func_params = prepareBitIsSetParams(executor, constants_owned);
   return cgen_state->emitCall("bit_is_set",
                               {func_params.bitmap_ptr_lv,
                                needle_i64,
                                func_params.min_val_lv,
                                func_params.max_val_lv,
                                func_params.null_val_lv,
                                cgen_state->llInt(null_bool_val)});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t InValuesBitmap::gpuBuffers ( ) const

inline

Definition at line 58 of file InValuesBitmap.h.

References gpu_buffers_.

58 { return gpu_buffers_.size(); }

InValuesBitmap::gpu_buffers_

std::vector< Data_Namespace::AbstractBuffer * > gpu_buffers_

Definition: InValuesBitmap.h:72

bool InValuesBitmap::hasNull ( ) const

Definition at line 195 of file InValuesBitmap.cpp.

References rhs_has_null_.

                                    {
   return rhs_has_null_;
 }

bool InValuesBitmap::isEmpty ( ) const

Definition at line 191 of file InValuesBitmap.cpp.

References bitsets_.

                                    {
   return bitsets_.empty();
 }

InValuesBitmap::BitIsSetParams InValuesBitmap::prepareBitIsSetParams	(	Executor *	executor,
		std::vector< std::shared_ptr< const Analyzer::Constant >> const &	constant_owned
	)		const

Definition at line 126 of file InValuesBitmap.cpp.

References InValuesBitmap::BitIsSetParams::bitmap_ptr_lv, bitsets_, CHECK_EQ, co_, CodeGenerator::codegenHoistedConstants(), device_count_, get_int_type(), CodegenUtil::hoistLiteral(), kBIGINT, kENCODING_NONE, max_val_, InValuesBitmap::BitIsSetParams::max_val_lv, min_val_, InValuesBitmap::BitIsSetParams::min_val_lv, null_val_, InValuesBitmap::BitIsSetParams::null_val_lv, and report::params.

Referenced by codegen().

                                                                                   {
   BitIsSetParams params;
   auto pi8_ty =
       llvm::PointerType::get(get_int_type(8, executor->cgen_state_->context_), 0);
   CodeGenerator code_generator(executor);
   params.null_val_lv =
       CodegenUtil::hoistLiteral(
           &code_generator, co_, make_datum<int64_t>(null_val_), kBIGINT, device_count_)
           .front();
   if (bitsets_.empty()) {
     auto const zero_lvs = CodegenUtil::hoistLiteral(
         &code_generator, co_, make_datum<int64_t>(0), kBIGINT, device_count_);
     params.min_val_lv = zero_lvs.front();
     params.max_val_lv = zero_lvs.front();
     params.bitmap_ptr_lv =
         executor->cgen_state_->ir_builder_.CreateIntToPtr(zero_lvs.front(), pi8_ty);
   } else {
     params.min_val_lv =
         CodegenUtil::hoistLiteral(
             &code_generator, co_, make_datum<int64_t>(min_val_), kBIGINT, device_count_)
             .front();
     params.max_val_lv =
         CodegenUtil::hoistLiteral(
             &code_generator, co_, make_datum<int64_t>(max_val_), kBIGINT, device_count_)
             .front();
     auto to_raw_ptr = [](const auto& ptr) { return ptr.get(); };
     auto begin = boost::make_transform_iterator(constant_owned.begin(), to_raw_ptr);
     auto end = boost::make_transform_iterator(constant_owned.end(), to_raw_ptr);
     std::vector<const Analyzer::Constant*> bitmap_constants(begin, end);
     const auto bitset_handle_lvs =
         code_generator.codegenHoistedConstants(bitmap_constants, kENCODING_NONE, {});
     CHECK_EQ(size_t(1), bitset_handle_lvs.size());
     params.bitmap_ptr_lv = executor->cgen_state_->ir_builder_.CreateIntToPtr(
         bitset_handle_lvs.front(), pi8_ty);
   }
   return params;
 }