#include <ChunkMetadataRecycler.h>

Inheritance diagram for ChunkMetadataRecycler:

Collaboration diagram for ChunkMetadataRecycler:

Public Member Functions
	ChunkMetadataRecycler ()

	std::numeric_limits ()

	std::numeric_limits ()

void	putItemToCache (QueryPlanHash key, std::optional< ChunkMetadataMap > item, CacheItemType item_type, DeviceIdentifier device_identifier, size_t item_size, size_t compute_time, std::optional< ChunkMetadataMetaInfo > meta_info=std::nullopt) override

void	initCache () override

void	clearCache () override

void	markCachedItemAsDirty (size_t table_key, std::unordered_set< QueryPlanHash > &key_set, CacheItemType item_type, DeviceIdentifier device_identifier) override

std::string	toString () const override

void	addQueryPlanDagForTableKeys (size_t hashed_query_plan_dag, const std::unordered_set< size_t > &table_keys, std::lock_guard< std::mutex > &lock)

std::optional < std::unordered_set< size_t > >	getMappedQueryPlanDagsWithTableKey (size_t table_key) const

void	removeTableKeyInfoFromQueryPlanDagMap (size_t table_key)

Public Member Functions inherited from DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >
	DataRecycler (const std::vector< CacheItemType > &item_types, size_t total_cache_size, size_t max_item_size, int num_gpus)

virtual	~DataRecycler ()=default

virtual std::optional < ChunkMetadataMap >	getItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::optional< ChunkMetadataMetaInfo > meta_info=std::nullopt)=0

void	markCachedItemAsDirtyImpl (QueryPlanHash key, CachedItemContainer &m) const

bool	isCachedItemDirty (QueryPlanHash key, CachedItemContainer &m) const

std::shared_ptr < CachedItemContainer >	getCachedItemContainer (CacheItemType item_type, DeviceIdentifier device_identifier) const

std::optional< CachedItem < std::optional < ChunkMetadataMap > , ChunkMetadataMetaInfo > >	getCachedItemWithoutConsideringMetaInfo (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, CachedItemContainer &m, std::lock_guard< std::mutex > &lock)

size_t	getCurrentNumCachedItems (CacheItemType item_type, DeviceIdentifier device_identifier) const

size_t	getCurrentNumDirtyCachedItems (CacheItemType item_type, DeviceIdentifier device_identifier) const

size_t	getCurrentNumCleanCachedItems (CacheItemType item_type, DeviceIdentifier device_identifier) const

size_t	getCurrentCacheSizeForDevice (CacheItemType item_type, DeviceIdentifier device_identifier) const

std::shared_ptr< CacheItemMetric >	getCachedItemMetric (CacheItemType item_type, DeviceIdentifier device_identifier, QueryPlanHash key) const

void	setTotalCacheSize (CacheItemType item_type, size_t new_total_cache_size)

void	setMaxCacheItemSize (CacheItemType item_type, size_t new_max_cache_item_size)

Private Member Functions
bool	hasItemInCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::lock_guard< std::mutex > &lock, std::optional< ChunkMetadataMetaInfo > meta_info=std::nullopt) const override

void	removeItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::lock_guard< std::mutex > &lock, std::optional< ChunkMetadataMetaInfo > meta_info=std::nullopt) override

void	cleanupCacheForInsertion (CacheItemType item_type, DeviceIdentifier device_identifier, size_t required_size, std::lock_guard< std::mutex > &lock, std::optional< ChunkMetadataMetaInfo > meta_info=std::nullopt) override

Private Attributes
std::unordered_map< size_t, std::unordered_set< size_t > >	table_key_to_query_plan_dag_map_

Additional Inherited Members
Public Types inherited from DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >
using	CachedItemContainer = std::vector< CachedItem< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >>

using	PerDeviceCacheItemContainer = std::unordered_map< DeviceIdentifier, std::shared_ptr< CachedItemContainer >>

using	PerTypeCacheItemContainer = std::unordered_map< CacheItemType, std::shared_ptr< PerDeviceCacheItemContainer >>

using	PerTypeCacheMetricTracker = std::unordered_map< CacheItemType, CacheMetricTracker >

Protected Member Functions inherited from DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >
void	removeCachedItemFromBeginning (CacheItemType item_type, DeviceIdentifier device_identifier, int offset)

void	sortCacheContainerByQueryMetric (CacheItemType item_type, DeviceIdentifier device_identifier)

std::mutex &	getCacheLock () const

CacheMetricTracker &	getMetricTracker (CacheItemType item_type)

CacheMetricTracker const &	getMetricTracker (CacheItemType item_type) const

std::unordered_set < CacheItemType > const &	getCacheItemType () const

PerTypeCacheItemContainer const &	getItemCache () const

Detailed Description

Definition at line 33 of file ChunkMetadataRecycler.h.

Constructor & Destructor Documentation

ChunkMetadataRecycler::ChunkMetadataRecycler ( )

inline

Definition at line 40 of file ChunkMetadataRecycler.h.

References CHUNK_METADATA.

41 : DataRecycler({CacheItemType::CHUNK_METADATA},

DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::DataRecycler

DataRecycler(const std::vector< CacheItemType > &item_types, size_t total_cache_size, size_t max_item_size, int num_gpus)

Definition: DataRecycler.h:458

CHUNK_METADATA

Definition: DataRecycler.h:46

Member Function Documentation

void ChunkMetadataRecycler::addQueryPlanDagForTableKeys	(	size_t	hashed_query_plan_dag,
		const std::unordered_set< size_t > &	table_keys,
		std::lock_guard< std::mutex > &	lock
	)

Definition at line 184 of file ChunkMetadataRecycler.cpp.

References table_key_to_query_plan_dag_map_.

Referenced by putItemToCache().

                                    {
   for (auto table_key : table_keys) {
     auto itr = table_key_to_query_plan_dag_map_.try_emplace(table_key).first;
     itr->second.insert(hashed_query_plan_dag);
   }
 }

Here is the caller graph for this function:

void ChunkMetadataRecycler::cleanupCacheForInsertion	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		size_t	required_size,
		std::lock_guard< std::mutex > &	lock,
		std::optional< ChunkMetadataMetaInfo >	meta_info = `std::nullopt`
	)

inlineoverrideprivatevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 99 of file ChunkMetadataRecycler.h.

104 {}

void ChunkMetadataRecycler::clearCache ( )

overridevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 121 of file ChunkMetadataRecycler.cpp.

References CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer(), DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), and VLOG.

                                        {
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto metadata_cache_container = getCachedItemContainer(
       CacheItemType::CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
 
   if (!metadata_cache_container->empty()) {
     VLOG(1) << "[" << CacheItemType::CHUNK_METADATA << ", "
             << DataRecyclerUtil::getDeviceIdentifierString(
                    CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER)
             << "] clear cache (# items: " << metadata_cache_container->size() << ")";
     metadata_cache_container->clear();
   }
 }

Here is the call graph for this function:

std::optional< std::unordered_set< size_t > > ChunkMetadataRecycler::getMappedQueryPlanDagsWithTableKey ( size_t table_key ) const

Definition at line 195 of file ChunkMetadataRecycler.cpp.

References DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCacheLock(), and table_key_to_query_plan_dag_map_.

                                                                                 {
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto it = table_key_to_query_plan_dag_map_.find(table_key);
   return it != table_key_to_query_plan_dag_map_.end() ? std::make_optional(it->second)
                                                       : std::nullopt;
 }

Here is the call graph for this function:

bool ChunkMetadataRecycler::hasItemInCache	(	QueryPlanHash	key,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		std::lock_guard< std::mutex > &	lock,
		std::optional< ChunkMetadataMetaInfo >	meta_info = `std::nullopt`
	)		const

overrideprivatevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 164 of file ChunkMetadataRecycler.cpp.

References CHECK_EQ, CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_chunk_metadata_cache, and DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer().

                                                         {
   if (!g_enable_data_recycler || !g_use_chunk_metadata_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return false;
   }
   CHECK_EQ(item_type, CacheItemType::CHUNK_METADATA);
   CHECK_EQ(device_identifier, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
   auto metadata_cache = getCachedItemContainer(item_type, device_identifier);
   auto candidate_it = std::find_if(
       metadata_cache->begin(), metadata_cache->end(), [&key](const auto& cached_item) {
         return cached_item.key == key;
       });
   return candidate_it != metadata_cache->end();
 }

Here is the call graph for this function:

void ChunkMetadataRecycler::initCache ( )

inlineoverridevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 62 of file ChunkMetadataRecycler.h.

62 {}

void ChunkMetadataRecycler::markCachedItemAsDirty	(	size_t	table_key,
		std::unordered_set< QueryPlanHash > &	key_set,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)

overridevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 135 of file ChunkMetadataRecycler.cpp.

References CHECK_EQ, CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, g_enable_data_recycler, g_use_chunk_metadata_cache, DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer(), DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCacheLock(), and DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::markCachedItemAsDirtyImpl().

                                         {
   if (!g_enable_data_recycler || !g_use_chunk_metadata_cache || key_set.empty()) {
     return;
   }
   CHECK_EQ(item_type, CacheItemType::CHUNK_METADATA);
   CHECK_EQ(device_identifier, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto metadata_cache = getCachedItemContainer(item_type, device_identifier);
   for (auto key : key_set) {
     markCachedItemAsDirtyImpl(key, *metadata_cache);
   }
 }

Here is the call graph for this function:

void ChunkMetadataRecycler::putItemToCache	(	QueryPlanHash	key,
		std::optional< ChunkMetadataMap >	item,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		size_t	item_size,
		size_t	compute_time,
		std::optional< ChunkMetadataMetaInfo >	meta_info = `std::nullopt`
	)

overridevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 53 of file ChunkMetadataRecycler.cpp.

References addQueryPlanDagForTableKeys(), CHECK, CHECK_EQ, CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_chunk_metadata_cache, DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer(), DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getMetricTracker(), removeItemFromCache(), and VLOG.

                                                   {
   if (!g_enable_data_recycler || !g_use_chunk_metadata_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return;
   }
   CHECK(meta_info.has_value());
   CHECK_EQ(item_type, CacheItemType::CHUNK_METADATA);
   CHECK_EQ(device_identifier, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto chunk_metadata_cache = getCachedItemContainer(item_type, device_identifier);
   CHECK(chunk_metadata_cache);
   auto candidate_it =
       std::find_if(chunk_metadata_cache->begin(),
                    chunk_metadata_cache->end(),
                    [&key](const auto& cached_item) { return cached_item.key == key; });
   bool has_cached_chunk_metadata = false;
   if (candidate_it != chunk_metadata_cache->end()) {
     has_cached_chunk_metadata = true;
     CHECK(candidate_it->meta_info);
     if (candidate_it->isDirty()) {
       removeItemFromCache(
           key, item_type, device_identifier, lock, candidate_it->meta_info);
       has_cached_chunk_metadata = false;
     }
   }
 
   if (!has_cached_chunk_metadata) {
     auto& metric_tracker = getMetricTracker(item_type);
     auto new_cache_metric_ptr = metric_tracker.putNewCacheItemMetric(
         key, device_identifier, item_size, compute_time);
     CHECK_EQ(item_size, new_cache_metric_ptr->getMemSize());
     VLOG(1) << "[" << item_type << ", "
             << DataRecyclerUtil::getDeviceIdentifierString(device_identifier)
             << "] Put item to cache (key: " << key << ")";
     chunk_metadata_cache->emplace_back(key, item, new_cache_metric_ptr, meta_info);
     if (!meta_info->input_table_keys.empty()) {
       addQueryPlanDagForTableKeys(key, meta_info->input_table_keys, lock);
     }
   }
   return;
 }

Here is the call graph for this function:

void ChunkMetadataRecycler::removeItemFromCache	(	QueryPlanHash	key,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		std::lock_guard< std::mutex > &	lock,
		std::optional< ChunkMetadataMetaInfo >	meta_info = `std::nullopt`
	)

overrideprivatevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 102 of file ChunkMetadataRecycler.cpp.

References CHECK_EQ, CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer(), DataRecyclerUtil::getDeviceIdentifierString(), and VLOG.

Referenced by putItemToCache().

                                                   {
   CHECK_EQ(item_type, CacheItemType::CHUNK_METADATA);
   CHECK_EQ(device_identifier, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
   auto metadata_cache = getCachedItemContainer(item_type, device_identifier);
   auto filter = [key](auto const& item) { return item.key == key; };
   auto itr = std::find_if(metadata_cache->cbegin(), metadata_cache->cend(), filter);
   if (itr != metadata_cache->cend()) {
     VLOG(1) << "[" << item_type << ", "
             << DataRecyclerUtil::getDeviceIdentifierString(device_identifier)
             << "] remove cached item from cache (key: " << key << ")";
     metadata_cache->erase(itr);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ChunkMetadataRecycler::removeTableKeyInfoFromQueryPlanDagMap ( size_t table_key )

Definition at line 202 of file ChunkMetadataRecycler.cpp.

References table_key_to_query_plan_dag_map_.

                                                                                   {
   table_key_to_query_plan_dag_map_.erase(table_key);
 }

ChunkMetadataRecycler::std::numeric_limits ( )

std::string ChunkMetadataRecycler::toString ( ) const

overridevirtual

Implements DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >.

Definition at line 152 of file ChunkMetadataRecycler.cpp.

References CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER, DataRecycler< std::optional< ChunkMetadataMap >, ChunkMetadataMetaInfo >::getCachedItemContainer(), and DataRecyclerUtil::getDeviceIdentifierString().

                                                 {
   auto chunk_metadata_cache_container = getCachedItemContainer(
       CacheItemType::CHUNK_METADATA, CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER);
   std::ostringstream oss;
   oss << "Chunk metadata cache:\n";
   oss << "Device: "
       << DataRecyclerUtil::getDeviceIdentifierString(
              CHUNK_METADATA_CACHE_DEVICE_IDENTIFIER)
       << "\n # cached chunk metadata: " << chunk_metadata_cache_container->size();
   return oss.str();
 }

Here is the call graph for this function:

Member Data Documentation

std::unordered_map<size_t, std::unordered_set<size_t> > ChunkMetadataRecycler::table_key_to_query_plan_dag_map_

private

Definition at line 107 of file ChunkMetadataRecycler.h.

Referenced by addQueryPlanDagForTableKeys(), getMappedQueryPlanDagsWithTableKey(), and removeTableKeyInfoFromQueryPlanDagMap().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation