#include <ResultSetRecycler.h>

Inheritance diagram for ResultSetRecycler:

Collaboration diagram for ResultSetRecycler:

Public Member Functions
	ResultSetRecycler ()

std::optional< std::vector < TargetMetaInfo > >	getOutputMetaInfo (QueryPlanHash key)

void	putItemToCache (QueryPlanHash key, ResultSetPtr item_ptr, CacheItemType item_type, DeviceIdentifier device_identifier, size_t item_size, size_t compute_time, std::optional< ResultSetMetaInfo > 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

std::tuple< QueryPlanHash, ResultSetPtr, std::optional < ResultSetMetaInfo > >	getCachedResultSetWithoutCacheKey (std::set< size_t > &visited, DeviceIdentifier device_identifier)

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)

bool	hasItemInCache (QueryPlanHash key)

std::vector< std::shared_ptr < Analyzer::Expr > > &	getTargetExprs (QueryPlanHash key) const

CacheMetricTracker &	getResultSetRecyclerMetricTracker ()

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

virtual	~DataRecycler ()=default

virtual ResultSetPtr	getItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::optional< ResultSetMetaInfo > 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 < ResultSetPtr, ResultSetMetaInfo > >	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)

Public Attributes
	g_query_resultset_cache_total_bytes

	g_max_cacheable_query_resultset_size_bytes

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

void	removeItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::lock_guard< std::mutex > &lock, std::optional< ResultSetMetaInfo > 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< ResultSetMetaInfo > 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< ResultSetPtr, ResultSetMetaInfo >
using	CachedItemContainer = std::vector< CachedItem< ResultSetPtr, ResultSetMetaInfo >>

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< ResultSetPtr, ResultSetMetaInfo >
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 40 of file ResultSetRecycler.h.

Constructor & Destructor Documentation

ResultSetRecycler::ResultSetRecycler ( )

inline

Definition at line 42 of file ResultSetRecycler.h.

43 : DataRecycler({CacheItemType::QUERY_RESULTSET},

DataRecycler< ResultSetPtr, ResultSetMetaInfo >::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

QUERY_RESULTSET

Definition: DataRecycler.h:45

Member Function Documentation

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

Definition at line 344 of file ResultSetRecycler.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 ResultSetRecycler::cleanupCacheForInsertion	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		size_t	required_size,
		std::lock_guard< std::mutex > &	lock,
		std::optional< ResultSetMetaInfo >	meta_info = `std::nullopt`
	)

overrideprivatevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 236 of file ResultSetRecycler.cpp.

References g_is_test_env, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker(), REMOVE, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::removeCachedItemFromBeginning(), and DataRecycler< ResultSetPtr, ResultSetMetaInfo >::sortCacheContainerByQueryMetric().

Referenced by putItemToCache().

                                               {
   int elimination_target_offset = 0;
   size_t removed_size = 0;
   auto& metric_tracker = getMetricTracker(item_type);
   auto actual_space_to_free = required_size;
   // cast total_cache_size to double for accurate calculation
   double moderate_free_space =
       static_cast<double>(metric_tracker.getTotalCacheSize()) / 2;
   if (!g_is_test_env && required_size < moderate_free_space) {
     // we try to make enough (and moderate) free space to avoid
     // too frequent cache clearance
     // we can expect that this strategy is likely to maintain cache hit ratio
     // since elimination targets are selected based on cache metrics including
     // # referenced (i.e., we try to keep frequently recycled items as long as we can)
     actual_space_to_free = moderate_free_space;
   }
   metric_tracker.sortCacheInfoByQueryMetric(device_identifier);
   auto cached_item_metrics = metric_tracker.getCacheItemMetrics(device_identifier);
   sortCacheContainerByQueryMetric(item_type, device_identifier);
   for (auto& metric : cached_item_metrics) {
     auto target_size = metric->getMemSize();
     ++elimination_target_offset;
     removed_size += target_size;
     if (removed_size > actual_space_to_free) {
       break;
     }
   }
 
   removeCachedItemFromBeginning(item_type, device_identifier, elimination_target_offset);
   metric_tracker.removeMetricFromBeginning(device_identifier, elimination_target_offset);
 
   metric_tracker.updateCurrentCacheSize(
       device_identifier, CacheUpdateAction::REMOVE, removed_size);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetRecycler::clearCache ( )

overridevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 276 of file ResultSetRecycler.cpp.

References CacheMetricTracker::clearCacheMetricTracker(), DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheItemType(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getItemCache(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker(), table_key_to_query_plan_dag_map_, and VLOG.

                                    {
   std::lock_guard<std::mutex> lock(getCacheLock());
   for (auto& item_type : getCacheItemType()) {
     getMetricTracker(item_type).clearCacheMetricTracker();
     auto item_cache = getItemCache().find(item_type)->second;
     for (auto& kv : *item_cache) {
       if (!kv.second->empty()) {
         VLOG(1) << "[" << item_type << ", "
                 << DataRecyclerUtil::getDeviceIdentifierString(
                        DataRecyclerUtil::CPU_DEVICE_IDENTIFIER)
                 << "] clear cache (# items: " << kv.second->size() << ")";
         kv.second->clear();
       }
     }
   }
   table_key_to_query_plan_dag_map_.clear();
 }

Here is the call graph for this function:

std::tuple< QueryPlanHash, ResultSetPtr, std::optional< ResultSetMetaInfo > > ResultSetRecycler::getCachedResultSetWithoutCacheKey	(	std::set< size_t > &	visited,
		DeviceIdentifier	device_identifier
	)

Definition at line 331 of file ResultSetRecycler.cpp.

References EMPTY_HASHED_PLAN_DAG_KEY, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), and QUERY_RESULTSET.

                                                                                          {
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto resultset_cache =
       getCachedItemContainer(CacheItemType::QUERY_RESULTSET, device_identifier);
   for (auto& rs : *resultset_cache) {
     if (!visited.count(rs.key)) {
       return std::make_tuple(rs.key, rs.cached_item, rs.meta_info);
     }
   }
   return std::make_tuple(EMPTY_HASHED_PLAN_DAG_KEY, nullptr, std::nullopt);
 }

Here is the call graph for this function:

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

Definition at line 355 of file ResultSetRecycler.cpp.

References DataRecycler< ResultSetPtr, ResultSetMetaInfo >::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:

std::optional< std::vector< TargetMetaInfo > > ResultSetRecycler::getOutputMetaInfo ( QueryPlanHash key )

Definition at line 92 of file ResultSetRecycler.cpp.

References CHECK, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_query_resultset_cache, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), QUERY_RESULTSET, and removeItemFromCache().

                        {
   if (!g_enable_data_recycler || !g_use_query_resultset_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return std::nullopt;
   }
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto resultset_cache = getCachedItemContainer(CacheItemType::QUERY_RESULTSET,
                                                 DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
   CHECK(resultset_cache);
   auto candidate_resultset_it = std::find_if(
       resultset_cache->begin(), resultset_cache->end(), [&key](const auto& cached_item) {
         return cached_item.key == key;
       });
   if (candidate_resultset_it != resultset_cache->end()) {
     CHECK(candidate_resultset_it->meta_info);
     if (candidate_resultset_it->isDirty()) {
       removeItemFromCache(key,
                           CacheItemType::QUERY_RESULTSET,
                           DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                           lock,
                           candidate_resultset_it->meta_info);
       return std::nullopt;
     }
     auto candidate_resultset = candidate_resultset_it->cached_item;
     auto output_meta_info = candidate_resultset->getTargetMetaInfo();
     return output_meta_info;
   }
   return std::nullopt;
 }

Here is the call graph for this function:

CacheMetricTracker& ResultSetRecycler::getResultSetRecyclerMetricTracker ( )

inline

Definition at line 93 of file ResultSetRecycler.h.

References DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker(), and QUERY_RESULTSET.

                                                           {
     return getMetricTracker(CacheItemType::QUERY_RESULTSET);
   }

Here is the call graph for this function:

std::vector< std::shared_ptr< Analyzer::Expr > > & ResultSetRecycler::getTargetExprs ( QueryPlanHash key ) const

Definition at line 366 of file ResultSetRecycler.cpp.

References CHECK, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), and QUERY_RESULTSET.

                              {
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto resultset_cache = getCachedItemContainer(CacheItemType::QUERY_RESULTSET,
                                                 DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
   CHECK(resultset_cache);
   auto candidate_resultset_it = std::find_if(
       resultset_cache->begin(), resultset_cache->end(), [&key](const auto& cached_item) {
         return cached_item.key == key;
       });
   CHECK(candidate_resultset_it != resultset_cache->end());
   CHECK(candidate_resultset_it->meta_info);
   return candidate_resultset_it->meta_info->getTargetExprs();
 }

Here is the call graph for this function:

bool ResultSetRecycler::hasItemInCache ( QueryPlanHash key )

Definition at line 39 of file ResultSetRecycler.cpp.

References DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), and QUERY_RESULTSET.

                                                         {
   std::lock_guard<std::mutex> lock(getCacheLock());
   return hasItemInCache(key,
                         CacheItemType::QUERY_RESULTSET,
                         DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                         lock,
                         std::nullopt);
 }

Here is the call graph for this function:

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

overrideprivatevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 21 of file ResultSetRecycler.cpp.

References CHECK, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_query_resultset_cache, and DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer().

                                                                                        {
   if (!g_enable_data_recycler || !g_use_query_resultset_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return false;
   }
   auto resultset_cache = getCachedItemContainer(item_type, device_identifier);
   CHECK(resultset_cache);
   auto candidate_resultset_it = std::find_if(
       resultset_cache->begin(), resultset_cache->end(), [&key](const auto& cached_item) {
         return cached_item.key == key;
       });
   return candidate_resultset_it != resultset_cache->end();
 }

Here is the call graph for this function:

void ResultSetRecycler::initCache ( )

inlineoverridevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 65 of file ResultSetRecycler.h.

65 {}

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

overridevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 294 of file ResultSetRecycler.cpp.

References g_enable_data_recycler, g_use_query_resultset_cache, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), removeItemFromCache(), and removeTableKeyInfoFromQueryPlanDagMap().

                                                                                   {
   if (!g_enable_data_recycler || !g_use_query_resultset_cache || key_set.empty()) {
     return;
   }
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto resultset_cache = getCachedItemContainer(item_type, device_identifier);
   for (auto key : key_set) {
     removeItemFromCache(key, item_type, device_identifier, lock, std::nullopt);
   }
   removeTableKeyInfoFromQueryPlanDagMap(table_key);
 }

Here is the call graph for this function:

void ResultSetRecycler::putItemToCache	(	QueryPlanHash	key,
		ResultSetPtr	item_ptr,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		size_t	item_size,
		size_t	compute_time,
		std::optional< ResultSetMetaInfo >	meta_info = `std::nullopt`
	)

overridevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 123 of file ResultSetRecycler.cpp.

References addQueryPlanDagForTableKeys(), AVAILABLE_AFTER_CLEANUP, CHECK, CHECK_EQ, CHECK_GT, cleanupCacheForInsertion(), EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_max_cacheable_query_resultset_size_bytes, g_query_resultset_cache_total_bytes, g_use_query_resultset_cache, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker(), logger::INFO, LOG, removeItemFromCache(), UNAVAILABLE, and VLOG.

                                                                                  {
   if (!g_enable_data_recycler || !g_use_query_resultset_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return;
   }
   CHECK(meta_info.has_value());
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto resultset_cache = getCachedItemContainer(item_type, device_identifier);
   auto candidate_resultset_it = std::find_if(
       resultset_cache->begin(), resultset_cache->end(), [&key](const auto& cached_item) {
         return cached_item.key == key;
       });
   bool has_cached_resultset = false;
   bool need_to_cleanup = false;
   if (candidate_resultset_it != resultset_cache->end()) {
     has_cached_resultset = true;
     CHECK(candidate_resultset_it->meta_info);
     if (candidate_resultset_it->isDirty()) {
       need_to_cleanup = true;
     } else if (candidate_resultset_it->cached_item->didOutputColumnar() !=
                item_ptr->didOutputColumnar()) {
       // we already have a cached resultset for the given query plan dag but
       // requested resultset output layout and that of cached one is different
       // so we remove the cached one and make a room for the resultset with different
       // layout
       need_to_cleanup = true;
       VLOG(1) << "Failed to recycle query resultset: mismatched cached resultset layout";
     }
   }
   if (need_to_cleanup) {
     // remove dirty cached resultset
     removeItemFromCache(
         key, item_type, device_identifier, lock, candidate_resultset_it->meta_info);
     has_cached_resultset = false;
   }
 
   if (!has_cached_resultset) {
     auto& metric_tracker = getMetricTracker(item_type);
     if (metric_tracker.getTotalCacheSize() != g_query_resultset_cache_total_bytes) {
       metric_tracker.setTotalCacheSize(g_query_resultset_cache_total_bytes);
     }
     if (metric_tracker.getMaxCacheItemSize() !=
         g_max_cacheable_query_resultset_size_bytes) {
       metric_tracker.setMaxCacheItemSize(g_max_cacheable_query_resultset_size_bytes);
     }
     auto cache_status = metric_tracker.canAddItem(device_identifier, item_size);
     if (cache_status == CacheAvailability::UNAVAILABLE) {
       LOG(INFO) << "Failed to keep a query resultset: the size of the resultset ("
                 << item_size << " bytes) exceeds the current system limit ("
                 << g_max_cacheable_query_resultset_size_bytes << " bytes)";
       return;
     } else if (cache_status == CacheAvailability::AVAILABLE_AFTER_CLEANUP) {
       auto required_size = metric_tracker.calculateRequiredSpaceForItemAddition(
           device_identifier, item_size);
       CHECK_GT(required_size, 0UL);
       LOG(INFO) << "Cleanup cached query resultset(s) to make a free space ("
                 << required_size << " bytes) to cache a new resultset";
       cleanupCacheForInsertion(item_type, device_identifier, required_size, lock);
     }
     auto new_cache_metric_ptr = metric_tracker.putNewCacheItemMetric(
         key, device_identifier, item_size, compute_time);
     CHECK_EQ(item_size, new_cache_metric_ptr->getMemSize());
     item_ptr->setCached(true);
     item_ptr->initStatus();
     VLOG(1) << "[" << item_type << ", "
             << DataRecyclerUtil::getDeviceIdentifierString(device_identifier)
             << "] Put query resultset to cache (key: " << key << ")";
     resultset_cache->emplace_back(key, item_ptr, 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 ResultSetRecycler::removeItemFromCache	(	QueryPlanHash	key,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		std::lock_guard< std::mutex > &	lock,
		std::optional< ResultSetMetaInfo >	meta_info = `std::nullopt`
	)

overrideprivatevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 204 of file ResultSetRecycler.cpp.

References CHECK, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_query_resultset_cache, DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCachedItemContainer(), DataRecyclerUtil::getDeviceIdentifierString(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker(), REMOVE, and VLOG.

Referenced by getOutputMetaInfo(), markCachedItemAsDirty(), and putItemToCache().

                                                                                       {
   if (!g_enable_data_recycler || !g_use_query_resultset_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return;
   }
   auto resultset_container = getCachedItemContainer(item_type, device_identifier);
   auto filter = [key](auto const& item) { return item.key == key; };
   auto itr =
       std::find_if(resultset_container->cbegin(), resultset_container->cend(), filter);
   if (itr == resultset_container->cend()) {
     return;
   } else {
     itr->cached_item->invalidateResultSetChunks();
     VLOG(1) << "[" << item_type << ", "
             << DataRecyclerUtil::getDeviceIdentifierString(device_identifier)
             << "] Remove item from cache (key: " << key << ")";
     resultset_container->erase(itr);
   }
   auto& cache_metrics = getMetricTracker(item_type);
   auto cache_metric = cache_metrics.getCacheItemMetric(key, device_identifier);
   CHECK(cache_metric);
   auto resultset_size = cache_metric->getMemSize();
   cache_metrics.removeCacheItemMetric(key, device_identifier);
   cache_metrics.updateCurrentCacheSize(
       device_identifier, CacheUpdateAction::REMOVE, resultset_size);
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetRecycler::removeTableKeyInfoFromQueryPlanDagMap ( size_t table_key )

Definition at line 362 of file ResultSetRecycler.cpp.

References table_key_to_query_plan_dag_map_.

Referenced by markCachedItemAsDirty().

                                                                               {
   table_key_to_query_plan_dag_map_.erase(table_key);
 }

Here is the caller graph for this function:

std::string ResultSetRecycler::toString ( ) const

overridevirtual

Implements DataRecycler< ResultSetPtr, ResultSetMetaInfo >.

Definition at line 309 of file ResultSetRecycler.cpp.

References DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getCacheItemType(), DataRecyclerUtil::getDeviceIdentifierString(), DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getItemCache(), and DataRecycler< ResultSetPtr, ResultSetMetaInfo >::getMetricTracker().

                                             {
   std::ostringstream oss;
   oss << "A current status of the query resultSet Recycler:\n";
   for (auto& item_type : getCacheItemType()) {
     oss << "\t" << item_type;
     auto& metric_tracker = getMetricTracker(item_type);
     oss << "\n\t# cached query resultsets:\n";
     auto item_cache = getItemCache().find(item_type)->second;
     for (auto& cache_container : *item_cache) {
       oss << "\t\tDevice"
           << DataRecyclerUtil::getDeviceIdentifierString(cache_container.first)
           << ", # query resultsets: " << cache_container.second->size() << "\n";
       for (auto& ht : *cache_container.second) {
         oss << "\t\t\tHT] " << ht.item_metric->toString() << "\n";
       }
     }
     oss << "\t" << metric_tracker.toString() << "\n";
   }
   return oss.str();
 }

Here is the call graph for this function:

Member Data Documentation

ResultSetRecycler::g_max_cacheable_query_resultset_size_bytes

Definition at line 43 of file ResultSetRecycler.h.

Referenced by putItemToCache().

ResultSetRecycler::g_query_resultset_cache_total_bytes

Definition at line 43 of file ResultSetRecycler.h.

Referenced by putItemToCache().

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

private

Definition at line 120 of file ResultSetRecycler.h.

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

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

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

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation