#include <RowSetMemoryOwner.h>

Inheritance diagram for RowSetMemoryOwner:

Collaboration diagram for RowSetMemoryOwner:

Classes
struct	CountDistinctBitmapBuffer

Public Types
enum	StringTranslationType { StringTranslationType::SOURCE_INTERSECTION, StringTranslationType::SOURCE_UNION }

Public Member Functions
	RowSetMemoryOwner (const size_t arena_block_size, const size_t executor_id)

void	setKernelMemoryAllocator (const size_t num_kernels)

int8_t *	allocate (const size_t num_bytes) override

int8_t *	allocate (const size_t num_bytes, const size_t thread_idx)

void	initCountDistinctBufferAllocator (size_t buffer_size, size_t thread_idx)

std::pair< int64_t *, bool >	allocateCachedGroupByBuffer (const size_t num_bytes, const size_t thread_idx)

int8_t *	allocateCountDistinctBuffer (const size_t num_bytes, const size_t thread_idx=0)

void	addCountDistinctBuffer (int8_t *count_distinct_buffer, const size_t bytes, const bool physical_buffer)

void	addCountDistinctSet (CountDistinctSet *count_distinct_set)

void	clearNonOwnedGroupByBuffers ()

void	addVarlenBuffer (void *varlen_buffer)

void	addVarlenInputBuffer (Data_Namespace::AbstractBuffer *buffer)

std::string *	addString (const std::string &str)

std::vector< int64_t > *	addArray (const std::vector< int64_t > &arr)

StringDictionaryProxy *	addStringDict (std::shared_ptr< StringDictionary > str_dict, const shared::StringDictKey &dict_key, const int64_t generation)

std::string	generate_translation_map_key (const shared::StringDictKey &source_proxy_dict_key, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

std::string	generate_translation_map_key (const shared::StringDictKey &source_proxy_dict_key, const shared::StringDictKey &dest_proxy_dict_key, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::IdMap *	addStringProxyIntersectionTranslationMap (const StringDictionaryProxy source_proxy, const StringDictionaryProxy dest_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::TranslationMap < Datum > *	addStringProxyNumericTranslationMap (const StringDictionaryProxy *source_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::IdMap *	addStringProxyUnionTranslationMap (const StringDictionaryProxy source_proxy, StringDictionaryProxy dest_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringOps_Namespace::StringOps *	getStringOps (const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

StringDictionaryProxy *	getStringDictProxy (const shared::StringDictKey &dict_key) const

StringDictionaryProxy *	getOrAddStringDictProxy (const shared::StringDictKey &dict_key, const bool with_generation)

void	addLiteralStringDictProxy (std::shared_ptr< StringDictionaryProxy > lit_str_dict_proxy)

StringDictionaryProxy *	getLiteralStringDictProxy () const

const StringDictionaryProxy::IdMap *	getOrAddStringProxyTranslationMap (const shared::StringDictKey &source_dict_id_in, const shared::StringDictKey &dest_dict_id_in, const bool with_generation, const StringTranslationType translation_map_type, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::TranslationMap < Datum > *	getOrAddStringProxyNumericTranslationMap (const shared::StringDictKey &source_dict_id_in, const bool with_generation, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

void	addColBuffer (const void *col_buffer)

	~RowSetMemoryOwner ()

std::shared_ptr < RowSetMemoryOwner >	cloneStrDictDataOnly ()

void	setDictionaryGenerations (StringDictionaryGenerations generations)

StringDictionaryGenerations &	getStringDictionaryGenerations ()

quantile::TDigest *	initTDigest (size_t thread_idx, ApproxQuantileDescriptor, double q)

void	reserveTDigestMemory (size_t thread_idx, size_t capacity)

void	setTableFunctionMetadata (const char key, const uint8_t raw_data, const size_t num_bytes, const TableFunctionMetadataType value_type)

void	getTableFunctionMetadata (const char key, const uint8_t &raw_data, size_t &num_bytes, TableFunctionMetadataType &value_type) const

AggMode *	allocateMode ()

Public Member Functions inherited from SimpleAllocator
virtual	~SimpleAllocator ()=default

Private Types
using	TDigestAllocator = FastAllocator< int8_t >

using	CountDistinctBufferAllocator = FastAllocator< int8_t >

using	MetadataValue = std::pair< std::vector< uint8_t >, TableFunctionMetadataType >

Private Member Functions
int8_t *	allocateUnlocked (const size_t num_bytes, const size_t thread_idx)

Private Attributes
std::vector < CountDistinctBitmapBuffer >	count_distinct_bitmaps_

std::vector< CountDistinctSet * >	count_distinct_sets_

std::vector< int64_t * >	non_owned_group_by_buffers_

std::vector< void * >	varlen_buffers_

std::list< std::string >	strings_

std::list< std::vector< int64_t > >	arrays_

std::unordered_map < shared::StringDictKey, std::shared_ptr < StringDictionaryProxy > >	str_dict_proxy_owned_

std::map< std::string, StringDictionaryProxy::IdMap >	str_proxy_intersection_translation_maps_owned_

std::map< std::string, StringDictionaryProxy::IdMap >	str_proxy_union_translation_maps_owned_

std::map< std::string, StringDictionaryProxy::TranslationMap < Datum > >	str_proxy_numeric_translation_maps_owned_

std::shared_ptr < StringDictionaryProxy >	lit_str_dict_proxy_

StringDictionaryGenerations	string_dictionary_generations_

std::vector< void * >	col_buffers_

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

std::deque< TDigestAllocator >	t_digest_allocators_

std::vector< std::unique_ptr < quantile::TDigest > >	t_digests_

std::map< std::string, std::shared_ptr < StringOps_Namespace::StringOps > >	string_ops_owned_

std::list< AggMode >	mode_maps_

size_t	arena_block_size_

std::vector< std::unique_ptr < Arena > >	allocators_

std::vector< std::unique_ptr < CountDistinctBufferAllocator > >	count_distinct_buffer_allocators_

size_t	executor_id_

std::mutex	state_mutex_

std::map< std::string, MetadataValue >	table_function_metadata_store_

std::mutex	table_function_metadata_store_mutex_

Friends
class	ResultSet

class	QueryExecutionContext

Detailed Description

Handles allocations and outputs for all stages in a query, either explicitly or via a managed allocator object

Definition at line 57 of file RowSetMemoryOwner.h.

Member Typedef Documentation

using RowSetMemoryOwner::CountDistinctBufferAllocator = FastAllocator<int8_t>

private

Definition at line 477 of file RowSetMemoryOwner.h.

using RowSetMemoryOwner::MetadataValue = std::pair<std::vector<uint8_t>, TableFunctionMetadataType>

private

Definition at line 485 of file RowSetMemoryOwner.h.

using RowSetMemoryOwner::TDigestAllocator = FastAllocator<int8_t>

private

Definition at line 466 of file RowSetMemoryOwner.h.

Member Enumeration Documentation

enum RowSetMemoryOwner::StringTranslationType

strong

Enumerator
SOURCE_INTERSECTION
SOURCE_UNION

Definition at line 70 of file RowSetMemoryOwner.h.

70 { SOURCE_INTERSECTION, SOURCE_UNION };

Constructor & Destructor Documentation

RowSetMemoryOwner::RowSetMemoryOwner	(	const size_t	arena_block_size,
		const size_t	executor_id
	)

inline

Definition at line 59 of file RowSetMemoryOwner.h.

References allocators_, arena_block_size_, count_distinct_buffer_allocators_, and g_use_cpu_mem_pool_for_output_buffers.

       : arena_block_size_(arena_block_size), executor_id_(executor_id) {
     // initialize shared allocator (i.e., allocators_[0])
     if (g_use_cpu_mem_pool_for_output_buffers) {
       allocators_.emplace_back(std::make_unique<CpuMgrArenaAllocator>());
     } else {
       allocators_.emplace_back(std::make_unique<DramArena>(arena_block_size_));
     }
     count_distinct_buffer_allocators_.resize(allocators_.size());
   }

RowSetMemoryOwner::~RowSetMemoryOwner ( )

inline

Definition at line 349 of file RowSetMemoryOwner.h.

References allocators_, CHECK, col_buffers_, count_distinct_sets_, executor_id_, varlen_buffers_, varlen_input_buffers_, and VLOG.

                        {
     std::ostringstream oss;
     oss << "Destruct RowSetMemoryOwner attached to Executor-" << executor_id_ << "{\t";
     int allocator_id = 0;
     for (auto const& allocator : allocators_) {
       auto const usedBytes = allocator->bytesUsed();
       if (usedBytes > 0) {
         oss << "allocator-" << allocator_id << ", byteUsed: " << usedBytes << "/"
             << allocator->totalBytes() << "\t";
       }
       ++allocator_id;
     }
     oss << "}";
     allocators_.clear();
     VLOG(1) << oss.str();
     for (auto count_distinct_set : count_distinct_sets_) {
       delete count_distinct_set;
     }
     for (auto varlen_buffer : varlen_buffers_) {
       free(varlen_buffer);
     }
     for (auto varlen_input_buffer : varlen_input_buffers_) {
       CHECK(varlen_input_buffer);
       varlen_input_buffer->unPin();
     }
     for (auto col_buffer : col_buffers_) {
       free(col_buffer);
     }
   }

Member Function Documentation

std::vector<int64_t>* RowSetMemoryOwner::addArray ( const std::vector< int64_t > & arr )

inline

Definition at line 199 of file RowSetMemoryOwner.h.

References arrays_, and state_mutex_.

                                                               {
     std::lock_guard<std::mutex> lock(state_mutex_);
     arrays_.emplace_back(arr);
     return &arrays_.back();
   }

void RowSetMemoryOwner::addColBuffer ( const void * col_buffer )

inline

Definition at line 344 of file RowSetMemoryOwner.h.

References col_buffers_, and state_mutex_.

                                             {
     std::lock_guard<std::mutex> lock(state_mutex_);
     col_buffers_.push_back(const_cast<void*>(col_buffer));
   }

void RowSetMemoryOwner::addCountDistinctBuffer	(	int8_t *	count_distinct_buffer,
		const size_t	bytes,
		const bool	physical_buffer
	)

inline

Definition at line 159 of file RowSetMemoryOwner.h.

References count_distinct_bitmaps_, and state_mutex_.

Referenced by allocateCountDistinctBuffer().

                                                           {
     std::lock_guard<std::mutex> lock(state_mutex_);
     count_distinct_bitmaps_.emplace_back(
         CountDistinctBitmapBuffer{count_distinct_buffer, bytes, physical_buffer});
   }

Here is the caller graph for this function:

void RowSetMemoryOwner::addCountDistinctSet ( CountDistinctSet * count_distinct_set )

inline

Definition at line 167 of file RowSetMemoryOwner.h.

References count_distinct_sets_, and state_mutex_.

                                                                  {
     std::lock_guard<std::mutex> lock(state_mutex_);
     count_distinct_sets_.push_back(count_distinct_set);
   }

void RowSetMemoryOwner::addLiteralStringDictProxy ( std::shared_ptr< StringDictionaryProxy > lit_str_dict_proxy )

inline

Definition at line 320 of file RowSetMemoryOwner.h.

References lit_str_dict_proxy_, and state_mutex_.

                                                                {
     std::lock_guard<std::mutex> lock(state_mutex_);
     lit_str_dict_proxy_ = lit_str_dict_proxy;
   }

std::string* RowSetMemoryOwner::addString ( const std::string & str )

inline

Definition at line 193 of file RowSetMemoryOwner.h.

References state_mutex_, and strings_.

                                              {
     std::lock_guard<std::mutex> lock(state_mutex_);
     strings_.emplace_back(str);
     return &strings_.back();
   }

StringDictionaryProxy* RowSetMemoryOwner::addStringDict	(	std::shared_ptr< StringDictionary >	str_dict,
		const shared::StringDictKey &	dict_key,
		const int64_t	generation
	)

inline

Definition at line 205 of file RowSetMemoryOwner.h.

References CHECK_EQ, state_mutex_, and str_dict_proxy_owned_.

                                                                  {
     std::lock_guard<std::mutex> lock(state_mutex_);
     auto it = str_dict_proxy_owned_.find(dict_key);
     if (it != str_dict_proxy_owned_.end()) {
       CHECK_EQ(it->second->getDictionary(), str_dict.get());
       it->second->updateGeneration(generation);
       return it->second.get();
     }
     it = str_dict_proxy_owned_
              .emplace(
                  dict_key,
                  std::make_shared<StringDictionaryProxy>(str_dict, dict_key, generation))
              .first;
     return it->second.get();
   }

const StringDictionaryProxy::IdMap* RowSetMemoryOwner::addStringProxyIntersectionTranslationMap	(	const StringDictionaryProxy *	source_proxy,
		const StringDictionaryProxy *	dest_proxy,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 243 of file RowSetMemoryOwner.h.

References StringDictionaryProxy::buildIntersectionTranslationMapToOtherProxy(), generate_translation_map_key(), StringDictionaryProxy::getDictionary(), StringDictionary::getDictKey(), state_mutex_, and str_proxy_intersection_translation_maps_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key =
         generate_translation_map_key(source_proxy->getDictionary()->getDictKey(),
                                      dest_proxy->getDictionary()->getDictKey(),
                                      string_op_infos);
     auto it = str_proxy_intersection_translation_maps_owned_.find(map_key);
     if (it == str_proxy_intersection_translation_maps_owned_.end()) {
       it = str_proxy_intersection_translation_maps_owned_
                .emplace(map_key,
                         source_proxy->buildIntersectionTranslationMapToOtherProxy(
                             dest_proxy, string_op_infos))
                .first;
     }
     return &it->second;
   }

Here is the call graph for this function:

const StringDictionaryProxy::TranslationMap<Datum>* RowSetMemoryOwner::addStringProxyNumericTranslationMap	(	const StringDictionaryProxy *	source_proxy,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 263 of file RowSetMemoryOwner.h.

References StringDictionaryProxy::buildNumericTranslationMap(), generate_translation_map_key(), StringDictionaryProxy::getDictionary(), StringDictionary::getDictKey(), and str_proxy_numeric_translation_maps_owned_.

                                                                          {
     const auto map_key = generate_translation_map_key(
         source_proxy->getDictionary()->getDictKey(), string_op_infos);
     auto it = str_proxy_numeric_translation_maps_owned_.lower_bound(map_key);
     if (it->first != map_key) {
       it = str_proxy_numeric_translation_maps_owned_.emplace_hint(
           it, map_key, source_proxy->buildNumericTranslationMap(string_op_infos));
     }
     return &it->second;
   }

Here is the call graph for this function:

const StringDictionaryProxy::IdMap* RowSetMemoryOwner::addStringProxyUnionTranslationMap	(	const StringDictionaryProxy *	source_proxy,
		StringDictionaryProxy *	dest_proxy,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 276 of file RowSetMemoryOwner.h.

References StringDictionaryProxy::buildUnionTranslationMapToOtherProxy(), generate_translation_map_key(), StringDictionaryProxy::getDictionary(), StringDictionary::getDictKey(), state_mutex_, and str_proxy_union_translation_maps_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key =
         generate_translation_map_key(source_proxy->getDictionary()->getDictKey(),
                                      dest_proxy->getDictionary()->getDictKey(),
                                      string_op_infos);
     auto it = str_proxy_union_translation_maps_owned_.find(map_key);
     if (it == str_proxy_union_translation_maps_owned_.end()) {
       it = str_proxy_union_translation_maps_owned_
                .emplace(map_key,
                         source_proxy->buildUnionTranslationMapToOtherProxy(
                             dest_proxy, string_op_infos))
                .first;
     }
     return &it->second;
   }

Here is the call graph for this function:

void RowSetMemoryOwner::addVarlenBuffer ( void * varlen_buffer )

inline

Definition at line 174 of file RowSetMemoryOwner.h.

References state_mutex_, and varlen_buffers_.

                                             {
     std::lock_guard<std::mutex> lock(state_mutex_);
     if (std::find(varlen_buffers_.begin(), varlen_buffers_.end(), varlen_buffer) ==
         varlen_buffers_.end()) {
       varlen_buffers_.push_back(varlen_buffer);
     }
   }

void RowSetMemoryOwner::addVarlenInputBuffer ( Data_Namespace::AbstractBuffer * buffer )

inline

Adds a GPU buffer containing a variable length input column. Variable length inputs on GPU are referenced in output projected targets and should not be freed until the query results have been resolved.

Definition at line 187 of file RowSetMemoryOwner.h.

References CHECK_EQ, Data_Namespace::AbstractBuffer::getType(), Data_Namespace::GPU_LEVEL, state_mutex_, and varlen_input_buffers_.

                                                                   {
     std::lock_guard<std::mutex> lock(state_mutex_);
     CHECK_EQ(buffer->getType(), Data_Namespace::MemoryLevel::GPU_LEVEL);
     varlen_input_buffers_.push_back(buffer);
   }

Here is the call graph for this function:

int8_t* RowSetMemoryOwner::allocate ( const size_t num_bytes )

inlineoverridevirtual

Implements SimpleAllocator.

Definition at line 103 of file RowSetMemoryOwner.h.

Referenced by anonymous_namespace{QueryMemoryInitializer.cpp}::alloc_group_by_buffer().

                                                     {
     constexpr size_t thread_idx = 0u;
     return allocate(num_bytes, thread_idx);
   }

Here is the caller graph for this function:

int8_t* RowSetMemoryOwner::allocate	(	const size_t	num_bytes,
		const size_t	thread_idx
	)

inline

Definition at line 109 of file RowSetMemoryOwner.h.

References allocateUnlocked(), allocators_, CHECK_LT, and state_mutex_.

                                                                     {
     CHECK_LT(thread_idx, allocators_.size());
     std::lock_guard<std::mutex> lock(state_mutex_);
     return allocateUnlocked(num_bytes, thread_idx);
   }

Here is the call graph for this function:

std::pair<int64_t*, bool> RowSetMemoryOwner::allocateCachedGroupByBuffer	(	const size_t	num_bytes,
		const size_t	thread_idx
	)

inline

Definition at line 128 of file RowSetMemoryOwner.h.

References allocators_, CHECK, CHECK_LT, g_allow_memory_status_log, non_owned_group_by_buffers_, state_mutex_, and VLOG.

Referenced by anonymous_namespace{QueryMemoryInitializer.cpp}::alloc_group_by_buffer().

                                                                                  {
     std::lock_guard<std::mutex> lock(state_mutex_);
     CHECK_LT(thread_idx, non_owned_group_by_buffers_.size());
     // First try cache
     if (non_owned_group_by_buffers_[thread_idx]) {  // not nullptr
       return std::make_pair(non_owned_group_by_buffers_[thread_idx], true);
     }
     // Was not in cache so must allocate
     auto allocator = allocators_[thread_idx].get();
     if (g_allow_memory_status_log) {
       VLOG(1) << "Try to allocate CPU memory: " << num_bytes << " bytes (THREAD-"
               << thread_idx << ")";
     }
     int64_t* group_by_buffer = reinterpret_cast<int64_t*>(allocator->allocate(num_bytes));
     CHECK(group_by_buffer);
     // Put in cache
     non_owned_group_by_buffers_[thread_idx] = group_by_buffer;
     return std::make_pair(group_by_buffer, false);
   }

Here is the caller graph for this function:

int8_t* RowSetMemoryOwner::allocateCountDistinctBuffer	(	const size_t	num_bytes,
		const size_t	thread_idx = `0`
	)

inline

Definition at line 149 of file RowSetMemoryOwner.h.

References addCountDistinctBuffer(), CHECK, CHECK_LT, and count_distinct_buffer_allocators_.

                                                                    {
     CHECK_LT(thread_idx, count_distinct_buffer_allocators_.size());
     CHECK(count_distinct_buffer_allocators_[thread_idx]);
     int8_t* buffer = count_distinct_buffer_allocators_[thread_idx]->allocate(num_bytes);
     std::memset(buffer, 0, num_bytes);
     addCountDistinctBuffer(buffer, num_bytes, /*physical_buffer=*/true);
     return buffer;
   }

Here is the call graph for this function:

AggMode* RowSetMemoryOwner::allocateMode ( )

inline

Definition at line 426 of file RowSetMemoryOwner.h.

References mode_maps_, and state_mutex_.

                           {
     std::lock_guard<std::mutex> lock(state_mutex_);
     return &mode_maps_.emplace_back();
   }

int8_t* RowSetMemoryOwner::allocateUnlocked	(	const size_t	num_bytes,
		const size_t	thread_idx
	)

inlineprivate

Definition at line 432 of file RowSetMemoryOwner.h.

References allocators_, g_allow_memory_status_log, and VLOG.

Referenced by allocate(), and initCountDistinctBufferAllocator().

                                                                             {
     if (g_allow_memory_status_log) {
       VLOG(1) << "Try to allocate CPU memory: " << num_bytes << " bytes (THREAD-"
               << thread_idx << ")";
     }
     auto allocator = allocators_[thread_idx].get();
     return reinterpret_cast<int8_t*>(allocator->allocate(num_bytes));
   }

Here is the caller graph for this function:

void RowSetMemoryOwner::clearNonOwnedGroupByBuffers ( )

inline

Definition at line 172 of file RowSetMemoryOwner.h.

References non_owned_group_by_buffers_.

172 { non_owned_group_by_buffers_.clear(); }

RowSetMemoryOwner::non_owned_group_by_buffers_

std::vector< int64_t * > non_owned_group_by_buffers_

Definition: RowSetMemoryOwner.h:449

std::shared_ptr<RowSetMemoryOwner> RowSetMemoryOwner::cloneStrDictDataOnly ( )

inline

Definition at line 379 of file RowSetMemoryOwner.h.

References arena_block_size_, executor_id_, lit_str_dict_proxy_, and str_dict_proxy_owned_.

                                                           {
     auto rtn = std::make_shared<RowSetMemoryOwner>(arena_block_size_, executor_id_);
     rtn->str_dict_proxy_owned_ = str_dict_proxy_owned_;
     rtn->lit_str_dict_proxy_ = lit_str_dict_proxy_;
     return rtn;
   }

std::string RowSetMemoryOwner::generate_translation_map_key	(	const shared::StringDictKey &	source_proxy_dict_key,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 223 of file RowSetMemoryOwner.h.

Referenced by addStringProxyIntersectionTranslationMap(), addStringProxyNumericTranslationMap(), addStringProxyUnionTranslationMap(), and getStringOps().

                                                                          {
     std::ostringstream oss;
     oss << "{source_dict_key: " << source_proxy_dict_key
         << " StringOps: " << string_op_infos << "}";
     return oss.str();
   }

Here is the caller graph for this function:

std::string RowSetMemoryOwner::generate_translation_map_key	(	const shared::StringDictKey &	source_proxy_dict_key,
		const shared::StringDictKey &	dest_proxy_dict_key,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 232 of file RowSetMemoryOwner.h.

                                                                          {
     std::ostringstream oss;
     oss << "{source_dict_key: " << source_proxy_dict_key
         << ", dest_dict_key: " << dest_proxy_dict_key << " StringOps: " << string_op_infos
         << "}";
     return oss.str();
   }

StringDictionaryProxy* RowSetMemoryOwner::getLiteralStringDictProxy ( ) const

inline

Definition at line 326 of file RowSetMemoryOwner.h.

References lit_str_dict_proxy_, and state_mutex_.

                                                            {
     std::lock_guard<std::mutex> lock(state_mutex_);
     return lit_str_dict_proxy_.get();
   }

StringDictionaryProxy * RowSetMemoryOwner::getOrAddStringDictProxy	(	const shared::StringDictKey &	dict_key,
		const bool	with_generation
	)

Definition at line 576 of file Execute.cpp.

References CHECK, CHECK_EQ, CHECK_LE, shared::StringDictKey::db_id, shared::StringDictKey::dict_id, g_cache_string_hash, Catalog_Namespace::SysCatalog::getCatalog(), Catalog_Namespace::SysCatalog::instance(), dict_ref_t::literalsDictId, and REGULAR_DICT.

                                 {
   const int dict_id{dict_key_in.dict_id < 0 ? REGULAR_DICT(dict_key_in.dict_id)
                                             : dict_key_in.dict_id};
   const auto catalog =
       Catalog_Namespace::SysCatalog::instance().getCatalog(dict_key_in.db_id);
   if (catalog) {
     const auto dd = catalog->getMetadataForDict(dict_id);
     if (dd) {
       auto dict_key = dict_key_in;
       dict_key.dict_id = dict_id;
       CHECK(dd->stringDict);
       CHECK_LE(dd->dictNBits, 32);
       const int64_t generation =
           with_generation ? string_dictionary_generations_.getGeneration(dict_key) : -1;
       return addStringDict(dd->stringDict, dict_key, generation);
     }
   }
   CHECK_EQ(dict_id, DictRef::literalsDictId);
   if (!lit_str_dict_proxy_) {
     DictRef literal_dict_ref(dict_key_in.db_id, DictRef::literalsDictId);
     std::shared_ptr<StringDictionary> tsd = std::make_shared<StringDictionary>(
         literal_dict_ref, "", false, true, g_cache_string_hash);
     lit_str_dict_proxy_ = std::make_shared<StringDictionaryProxy>(
         tsd, shared::StringDictKey{literal_dict_ref.dbId, literal_dict_ref.dictId}, 0);
   }
   return lit_str_dict_proxy_.get();
 }

Here is the call graph for this function:

const StringDictionaryProxy::TranslationMap< Datum > * RowSetMemoryOwner::getOrAddStringProxyNumericTranslationMap	(	const shared::StringDictKey &	source_dict_id_in,
		const bool	with_generation,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

Definition at line 669 of file Execute.cpp.

                                                                        {
   const auto source_proxy = getOrAddStringDictProxy(source_dict_key_in, with_generation);
   return addStringProxyNumericTranslationMap(source_proxy, string_op_infos);
 }

const StringDictionaryProxy::IdMap * RowSetMemoryOwner::getOrAddStringProxyTranslationMap	(	const shared::StringDictKey &	source_dict_id_in,
		const shared::StringDictKey &	dest_dict_id_in,
		const bool	with_generation,
		const StringTranslationType	translation_map_type,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

Definition at line 652 of file Execute.cpp.

References SOURCE_INTERSECTION.

                                                                        {
   const auto source_proxy = getOrAddStringDictProxy(source_dict_key_in, with_generation);
   const auto dest_proxy = getOrAddStringDictProxy(dest_dict_key_in, with_generation);
   if (translation_type == RowSetMemoryOwner::StringTranslationType::SOURCE_INTERSECTION) {
     return addStringProxyIntersectionTranslationMap(
         source_proxy, dest_proxy, string_op_infos);
   } else {
     return addStringProxyUnionTranslationMap(source_proxy, dest_proxy, string_op_infos);
   }
 }

StringDictionaryGenerations& RowSetMemoryOwner::getStringDictionaryGenerations ( )

inline

Definition at line 390 of file RowSetMemoryOwner.h.

References string_dictionary_generations_.

                                                                 {
     return string_dictionary_generations_;
   }

StringDictionaryProxy* RowSetMemoryOwner::getStringDictProxy ( const shared::StringDictKey & dict_key ) const

inline

Definition at line 310 of file RowSetMemoryOwner.h.

References CHECK, state_mutex_, and str_dict_proxy_owned_.

                                                                                        {
     std::lock_guard<std::mutex> lock(state_mutex_);
     auto it = str_dict_proxy_owned_.find(dict_key);
     CHECK(it != str_dict_proxy_owned_.end());
     return it->second.get();
   }

const StringOps_Namespace::StringOps* RowSetMemoryOwner::getStringOps ( const std::vector< StringOps_Namespace::StringOpInfo > & string_op_infos )

inline

Definition at line 296 of file RowSetMemoryOwner.h.

References generate_translation_map_key(), state_mutex_, and string_ops_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key = generate_translation_map_key({}, {}, string_op_infos);
     auto it = string_ops_owned_.find(map_key);
     if (it == string_ops_owned_.end()) {
       it = string_ops_owned_
                .emplace(map_key,
                         std::make_shared<StringOps_Namespace::StringOps>(string_op_infos))
                .first;
     }
     return it->second.get();
   }

Here is the call graph for this function:

void RowSetMemoryOwner::getTableFunctionMetadata	(	const char *	key,
		const uint8_t *&	raw_data,
		size_t &	num_bytes,
		TableFunctionMetadataType &	value_type
	)		const

inline

Definition at line 411 of file RowSetMemoryOwner.h.

References table_function_metadata_store_, and table_function_metadata_store_mutex_.

                                                                              {
     std::lock_guard<std::mutex> lock(table_function_metadata_store_mutex_);
     auto const itr = table_function_metadata_store_.find(key);
     if (itr == table_function_metadata_store_.end()) {
       throw std::runtime_error("Failed to find Table Function Metadata with key '" +
                                std::string(key) + "'");
     }
     raw_data = itr->second.first.data();
     num_bytes = itr->second.first.size();
     value_type = itr->second.second;
   }

void RowSetMemoryOwner::initCountDistinctBufferAllocator	(	size_t	buffer_size,
		size_t	thread_idx
	)

inline

Definition at line 115 of file RowSetMemoryOwner.h.

References allocateUnlocked(), CHECK_LT, count_distinct_buffer_allocators_, state_mutex_, and VLOG.

                                                                                {
     std::lock_guard<std::mutex> lock(state_mutex_);
     VLOG(2) << "Count distinct buffer allocator initialized with buffer_size: "
             << buffer_size << ", thread_idx: " << thread_idx;
     CHECK_LT(thread_idx, count_distinct_buffer_allocators_.size());
     if (count_distinct_buffer_allocators_[thread_idx]) {
       VLOG(2) << "Replacing count_distinct_buffer_allocators_[" << thread_idx << "].";
     }
     count_distinct_buffer_allocators_[thread_idx] =
         std::make_unique<CountDistinctBufferAllocator>(
             allocateUnlocked(buffer_size, thread_idx), buffer_size);
   }

Here is the call graph for this function:

quantile::TDigest * RowSetMemoryOwner::initTDigest	(	size_t	thread_idx,
		ApproxQuantileDescriptor	desc,
		double	q
	)

Definition at line 677 of file Execute.cpp.

References ApproxQuantileDescriptor::buffer_size, and ApproxQuantileDescriptor::centroids_size.

                                                                   {
   static_assert(std::is_trivially_copyable_v<ApproxQuantileDescriptor>);
   std::lock_guard<std::mutex> lock(state_mutex_);
   auto t_digest = std::make_unique<quantile::TDigest>(
       q, &t_digest_allocators_[thread_idx], desc.buffer_size, desc.centroids_size);
   return t_digests_.emplace_back(std::move(t_digest)).get();
 }

void RowSetMemoryOwner::reserveTDigestMemory	(	size_t	thread_idx,
		size_t	capacity
	)

Definition at line 687 of file Execute.cpp.

References VLOG.

                                                                                {
   std::unique_lock<std::mutex> lock(state_mutex_);
   if (t_digest_allocators_.size() <= thread_idx) {
     t_digest_allocators_.resize(thread_idx + 1u);
   }
   if (t_digest_allocators_[thread_idx].capacity()) {
     // This can only happen when a thread_idx is re-used.  In other words,
     // two or more kernels have launched (serially!) using the same thread_idx.
     // This is ok since TDigestAllocator does not own the memory it allocates.
     VLOG(2) << "Replacing t_digest_allocators_[" << thread_idx << "].";
   }
   lock.unlock();
   // This is not locked due to use of same state_mutex_ during allocation.
   // The corresponding deallocation happens in ~DramArena().
   int8_t* const buffer = allocate(capacity, thread_idx);
   lock.lock();
   t_digest_allocators_[thread_idx] = TDigestAllocator(buffer, capacity);
 }

void RowSetMemoryOwner::setDictionaryGenerations ( StringDictionaryGenerations generations )

inline

Definition at line 386 of file RowSetMemoryOwner.h.

References string_dictionary_generations_.

                                                                          {
     string_dictionary_generations_ = generations;
   }

void RowSetMemoryOwner::setKernelMemoryAllocator ( const size_t num_kernels )

inline

Definition at line 72 of file RowSetMemoryOwner.h.

References allocators_, arena_block_size_, CHECK_EQ, CHECK_GE, CHECK_GT, count_distinct_buffer_allocators_, executor_id_, g_use_cpu_mem_pool_for_output_buffers, non_owned_group_by_buffers_, and VLOG.

                                                           {
     CHECK_GT(num_kernels, static_cast<size_t>(0));
     CHECK_EQ(non_owned_group_by_buffers_.size(), static_cast<size_t>(0));
     // buffer for kernels starts with one-based indexing
     auto const required_num_kernels = num_kernels + 1;
     non_owned_group_by_buffers_.resize(required_num_kernels, nullptr);
     // sometimes the same RSMO instance handles multiple work units or even multiple query
     // steps (this means the RSMO's owner, an Executor instance, takes a responsibility to
     // proceed them) so, if the first query step has M allocators but if the second query
     // step requires N allocators where N > M, let's allocate M - N allocators instead of
     // recreating M new allocators
     if (required_num_kernels > allocators_.size()) {
       auto const required_num_allocators = required_num_kernels - allocators_.size();
       VLOG(1) << "Prepare " << required_num_allocators
               << " memory allocator(s) (Executor-" << executor_id_
               << ", # existing allocator(s): " << allocators_.size()
               << ", # requested allocator(s): " << required_num_kernels << ")";
       for (size_t i = 0; i < required_num_allocators; i++) {
         if (g_use_cpu_mem_pool_for_output_buffers) {
           allocators_.emplace_back(std::make_unique<CpuMgrArenaAllocator>());
         } else {
           // todo (yoonmin): can we determine better default min_block_size per query?
           allocators_.emplace_back(std::make_unique<DramArena>(arena_block_size_));
         }
       }
     }
     CHECK_GE(allocators_.size(), required_num_kernels);
     count_distinct_buffer_allocators_.resize(allocators_.size());
   }

void RowSetMemoryOwner::setTableFunctionMetadata	(	const char *	key,
		const uint8_t *	raw_data,
		const size_t	num_bytes,
		const TableFunctionMetadataType	value_type
	)

inline

Definition at line 401 of file RowSetMemoryOwner.h.

References table_function_metadata_store_, and table_function_metadata_store_mutex_.

                                                                             {
     MetadataValue metadata_value(num_bytes, value_type);
     std::memcpy(metadata_value.first.data(), raw_data, num_bytes);
     std::lock_guard<std::mutex> lock(table_function_metadata_store_mutex_);
     table_function_metadata_store_[key] = std::move(metadata_value);
   }

Friends And Related Function Documentation

friend class QueryExecutionContext

friend

Definition at line 490 of file RowSetMemoryOwner.h.

friend class ResultSet

friend

Definition at line 489 of file RowSetMemoryOwner.h.

Member Data Documentation

std::vector<std::unique_ptr<Arena> > RowSetMemoryOwner::allocators_

private

Definition at line 475 of file RowSetMemoryOwner.h.

Referenced by allocate(), allocateCachedGroupByBuffer(), allocateUnlocked(), RowSetMemoryOwner(), setKernelMemoryAllocator(), and ~RowSetMemoryOwner().

size_t RowSetMemoryOwner::arena_block_size_

private

Definition at line 474 of file RowSetMemoryOwner.h.

Referenced by cloneStrDictDataOnly(), RowSetMemoryOwner(), and setKernelMemoryAllocator().

std::list<std::vector<int64_t> > RowSetMemoryOwner::arrays_

private

Definition at line 452 of file RowSetMemoryOwner.h.

Referenced by addArray().

std::vector<void*> RowSetMemoryOwner::col_buffers_

private

Definition at line 463 of file RowSetMemoryOwner.h.

Referenced by addColBuffer(), and ~RowSetMemoryOwner().

std::vector<CountDistinctBitmapBuffer> RowSetMemoryOwner::count_distinct_bitmaps_

private

Definition at line 447 of file RowSetMemoryOwner.h.

Referenced by addCountDistinctBuffer().

std::vector<std::unique_ptr<CountDistinctBufferAllocator> > RowSetMemoryOwner::count_distinct_buffer_allocators_

private

Definition at line 479 of file RowSetMemoryOwner.h.

Referenced by allocateCountDistinctBuffer(), initCountDistinctBufferAllocator(), RowSetMemoryOwner(), and setKernelMemoryAllocator().

std::vector<CountDistinctSet*> RowSetMemoryOwner::count_distinct_sets_

private

Definition at line 448 of file RowSetMemoryOwner.h.

Referenced by addCountDistinctSet(), and ~RowSetMemoryOwner().

size_t RowSetMemoryOwner::executor_id_

private

Definition at line 481 of file RowSetMemoryOwner.h.

Referenced by cloneStrDictDataOnly(), setKernelMemoryAllocator(), and ~RowSetMemoryOwner().

std::shared_ptr<StringDictionaryProxy> RowSetMemoryOwner::lit_str_dict_proxy_

private

Definition at line 461 of file RowSetMemoryOwner.h.

Referenced by addLiteralStringDictProxy(), cloneStrDictDataOnly(), and getLiteralStringDictProxy().

std::list<AggMode> RowSetMemoryOwner::mode_maps_

private

Definition at line 472 of file RowSetMemoryOwner.h.

Referenced by allocateMode().

std::vector<int64_t*> RowSetMemoryOwner::non_owned_group_by_buffers_

private

Definition at line 449 of file RowSetMemoryOwner.h.

Referenced by allocateCachedGroupByBuffer(), clearNonOwnedGroupByBuffers(), and setKernelMemoryAllocator().

std::mutex RowSetMemoryOwner::state_mutex_

mutableprivate

std::unordered_map<shared::StringDictKey, std::shared_ptr<StringDictionaryProxy> > RowSetMemoryOwner::str_dict_proxy_owned_

private

Definition at line 454 of file RowSetMemoryOwner.h.

Referenced by addStringDict(), cloneStrDictDataOnly(), and getStringDictProxy().

std::map<std::string, StringDictionaryProxy::IdMap> RowSetMemoryOwner::str_proxy_intersection_translation_maps_owned_

private

Definition at line 456 of file RowSetMemoryOwner.h.

Referenced by addStringProxyIntersectionTranslationMap().

std::map<std::string, StringDictionaryProxy::TranslationMap<Datum> > RowSetMemoryOwner::str_proxy_numeric_translation_maps_owned_

private

Definition at line 460 of file RowSetMemoryOwner.h.

Referenced by addStringProxyNumericTranslationMap().

std::map<std::string, StringDictionaryProxy::IdMap> RowSetMemoryOwner::str_proxy_union_translation_maps_owned_

private

Definition at line 458 of file RowSetMemoryOwner.h.

Referenced by addStringProxyUnionTranslationMap().

StringDictionaryGenerations RowSetMemoryOwner::string_dictionary_generations_

private

Definition at line 462 of file RowSetMemoryOwner.h.

Referenced by getStringDictionaryGenerations(), and setDictionaryGenerations().

std::map<std::string, std::shared_ptr<StringOps_Namespace::StringOps> > RowSetMemoryOwner::string_ops_owned_

private

Definition at line 471 of file RowSetMemoryOwner.h.

Referenced by getStringOps().

std::list<std::string> RowSetMemoryOwner::strings_

private

Definition at line 451 of file RowSetMemoryOwner.h.

Referenced by addString().

std::deque<TDigestAllocator> RowSetMemoryOwner::t_digest_allocators_

private

Definition at line 467 of file RowSetMemoryOwner.h.

std::vector<std::unique_ptr<quantile::TDigest> > RowSetMemoryOwner::t_digests_

private

Definition at line 468 of file RowSetMemoryOwner.h.

std::map<std::string, MetadataValue> RowSetMemoryOwner::table_function_metadata_store_

private

Definition at line 486 of file RowSetMemoryOwner.h.

Referenced by getTableFunctionMetadata(), and setTableFunctionMetadata().

std::mutex RowSetMemoryOwner::table_function_metadata_store_mutex_

mutableprivate

Definition at line 487 of file RowSetMemoryOwner.h.

Referenced by getTableFunctionMetadata(), and setTableFunctionMetadata().

std::vector<void*> RowSetMemoryOwner::varlen_buffers_

private

Definition at line 450 of file RowSetMemoryOwner.h.

Referenced by addVarlenBuffer(), and ~RowSetMemoryOwner().

std::vector<Data_Namespace::AbstractBuffer*> RowSetMemoryOwner::varlen_input_buffers_

private

Definition at line 464 of file RowSetMemoryOwner.h.

Referenced by addVarlenInputBuffer(), and ~RowSetMemoryOwner().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Descriptors/RowSetMemoryOwner.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Execute.cpp

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation