#include <DataRecycler.h>

Public Member Functions
	CacheMetricTracker (CacheItemType cache_item_type, size_t total_cache_size, size_t max_cache_item_size, int num_gpus=0)

std::vector< std::shared_ptr < CacheItemMetric > > &	getCacheItemMetrics (DeviceIdentifier device_identifier)

std::shared_ptr< CacheItemMetric >	getCacheItemMetric (QueryPlanHash key, DeviceIdentifier device_identifier) const

void	setCurrentCacheSize (DeviceIdentifier device_identifier, size_t bytes)

std::optional< size_t >	getCurrentCacheSize (DeviceIdentifier key) const

std::shared_ptr< CacheItemMetric >	putNewCacheItemMetric (QueryPlanHash key, DeviceIdentifier device_identifier, size_t mem_size, size_t compute_time)

void	removeCacheItemMetric (QueryPlanHash key, DeviceIdentifier device_identifier)

void	removeMetricFromBeginning (DeviceIdentifier device_identifier, int offset)

size_t	calculateRequiredSpaceForItemAddition (DeviceIdentifier device_identifier, size_t item_size) const

void	clearCacheMetricTracker ()

CacheAvailability	canAddItem (DeviceIdentifier device_identifier, size_t item_size) const

void	updateCurrentCacheSize (DeviceIdentifier device_identifier, CacheUpdateAction action, size_t size)

void	sortCacheInfoByQueryMetric (DeviceIdentifier device_identifier)

std::string	toString () const

size_t	getTotalCacheSize () const

size_t	getMaxCacheItemSize () const

void	setTotalCacheSize (size_t new_total_cache_size)

void	setMaxCacheItemSize (size_t new_max_cache_item_size)

Static Public Member Functions
static CacheMetricInfoMap::mapped_type::const_iterator	getCacheItemMetricItr (QueryPlanHash key, CacheMetricInfoMap::mapped_type const &metrics)

static std::shared_ptr < CacheItemMetric >	getCacheItemMetricImpl (QueryPlanHash key, CacheMetricInfoMap::mapped_type const &metrics)

Private Attributes
CacheItemType	item_type_

size_t	total_cache_size_

size_t	max_cache_item_size_

CacheMetricInfoMap	cache_metrics_

CacheSizeMap	current_cache_size_in_bytes_

Detailed Description

Definition at line 183 of file DataRecycler.h.

Constructor & Destructor Documentation

CacheMetricTracker::CacheMetricTracker	(	CacheItemType	cache_item_type,
		size_t	total_cache_size,
		size_t	max_cache_item_size,
		int	num_gpus = `0`
	)

inline

Definition at line 185 of file DataRecycler.h.

References cache_metrics_, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, current_cache_size_in_bytes_, logger::INFO, LOG, and total_cache_size_.

       : item_type_(cache_item_type)
       , total_cache_size_(total_cache_size)
       , max_cache_item_size_(max_cache_item_size) {
     // initialize cache metrics for each device: CPU, GPU0, GPU1, ...
     // Currently we only consider maintaining our cache in CPU-memory
     for (int gpu_device_identifier = num_gpus; gpu_device_identifier >= 1;
          --gpu_device_identifier) {
       cache_metrics_.emplace(gpu_device_identifier,
                              std::vector<std::shared_ptr<CacheItemMetric>>());
       current_cache_size_in_bytes_.emplace(gpu_device_identifier, 0);
     }
     cache_metrics_.emplace(DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                            std::vector<std::shared_ptr<CacheItemMetric>>());
     current_cache_size_in_bytes_.emplace(DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, 0);
 
     if (total_cache_size_ < 1024 * 1024 * 256) {
       LOG(INFO) << "The total cache size of " << cache_item_type
                 << " is set too low, so we suggest raising it larger than 256MB";
     }
 
     if (max_cache_item_size < 1024 * 1024 * 10) {
       LOG(INFO)
           << "The maximum item size of " << cache_item_type
           << " that can be cached is set too low, we suggest raising it larger than 10MB";
     }
     if (max_cache_item_size > total_cache_size_) {
       LOG(INFO) << "The maximum item size of " << cache_item_type
                 << " is set larger than its total cache size, so we force to set the "
                    "maximum item size as equal to the total cache size";
       max_cache_item_size = total_cache_size_;
     }
   }

Member Function Documentation

size_t CacheMetricTracker::calculateRequiredSpaceForItemAddition	(	DeviceIdentifier	device_identifier,
		size_t	item_size
	)		const

inline

Definition at line 307 of file DataRecycler.h.

References CHECK, CHECK_LE, current_cache_size_in_bytes_, and total_cache_size_.

                                                                        {
     auto it = current_cache_size_in_bytes_.find(device_identifier);
     CHECK(it != current_cache_size_in_bytes_.end());
     CHECK_LE(item_size, total_cache_size_);
     const auto current_cache_size = it->second;
     long rem = total_cache_size_ - current_cache_size;
     return rem < 0 ? item_size : item_size - rem;
   }

CacheAvailability CacheMetricTracker::canAddItem	(	DeviceIdentifier	device_identifier,
		size_t	item_size
	)		const

inline

Definition at line 333 of file DataRecycler.h.

References AVAILABLE, AVAILABLE_AFTER_CLEANUP, CHECK, getCurrentCacheSize(), max_cache_item_size_, total_cache_size_, and UNAVAILABLE.

                                                        {
     if (item_size > max_cache_item_size_ || item_size > total_cache_size_) {
       return CacheAvailability::UNAVAILABLE;
     }
     // now we know that a cache can hold the new item since its size is less than
     // per-item maximum size limit
     // check if we need to remove some (or all) of cached item to make a room
     // for the new item
     auto current_cache_size = getCurrentCacheSize(device_identifier);
     CHECK(current_cache_size.has_value());
     auto cache_size_after_addition = *current_cache_size + item_size;
     if (cache_size_after_addition > total_cache_size_) {
       // if so, we need to remove the item to hold the new one within the cache
       return CacheAvailability::AVAILABLE_AFTER_CLEANUP;
     }
     // cache has a sufficient space to hold the new item
     // thus, there is no need to remove cached item
     return CacheAvailability::AVAILABLE;
   }

Here is the call graph for this function:

void CacheMetricTracker::clearCacheMetricTracker ( )

inline

Definition at line 317 of file DataRecycler.h.

References cache_metrics_, CHECK_EQ, current_cache_size_in_bytes_, getCacheItemMetrics(), getCurrentCacheSize(), item_type_, REMOVE, updateCurrentCacheSize(), and VLOG.

Referenced by ResultSetRecycler::clearCache(), and HashtableRecycler::clearCache().

                                  {
     for (auto& kv : current_cache_size_in_bytes_) {
       auto cache_item_metrics = getCacheItemMetrics(kv.first);
       if (kv.first > 0) {
         VLOG(1) << "[" << item_type_ << "]"
                 << "] clear cache metrics (# items: " << kv.first << ", " << kv.second
                 << " bytes)";
       }
       updateCurrentCacheSize(kv.first, CacheUpdateAction::REMOVE, kv.second);
       CHECK_EQ(getCurrentCacheSize(kv.first).value(), 0u);
     }
     for (auto& kv : cache_metrics_) {
       kv.second.clear();
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<CacheItemMetric> CacheMetricTracker::getCacheItemMetric	(	QueryPlanHash	key,
		DeviceIdentifier	device_identifier
	)		const

inline

Definition at line 243 of file DataRecycler.h.

References cache_metrics_, and getCacheItemMetricImpl().

                                                 {
     auto itr = cache_metrics_.find(device_identifier);
     return itr == cache_metrics_.cend() ? nullptr
                                         : getCacheItemMetricImpl(key, itr->second);
   }

Here is the call graph for this function:

static std::shared_ptr<CacheItemMetric> CacheMetricTracker::getCacheItemMetricImpl	(	QueryPlanHash	key,
		CacheMetricInfoMap::mapped_type const &	metrics
	)

inlinestatic

Definition at line 229 of file DataRecycler.h.

References getCacheItemMetricItr().

Referenced by getCacheItemMetric(), and putNewCacheItemMetric().

                                                     {
     auto itr = getCacheItemMetricItr(key, metrics);
     return itr == metrics.cend() ? nullptr : *itr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static CacheMetricInfoMap::mapped_type::const_iterator CacheMetricTracker::getCacheItemMetricItr	(	QueryPlanHash	key,
		CacheMetricInfoMap::mapped_type const &	metrics
	)

inlinestatic

Definition at line 222 of file DataRecycler.h.

Referenced by getCacheItemMetricImpl(), and removeCacheItemMetric().

                                                     {
     auto same_hash = [key](auto itr) { return itr->getQueryPlanHash() == key; };
     return std::find_if(metrics.cbegin(), metrics.cend(), same_hash);
   }

Here is the caller graph for this function:

std::vector<std::shared_ptr<CacheItemMetric> >& CacheMetricTracker::getCacheItemMetrics ( DeviceIdentifier device_identifier )

inline

Definition at line 236 of file DataRecycler.h.

References cache_metrics_, and CHECK.

Referenced by clearCacheMetricTracker(), removeCacheItemMetric(), removeMetricFromBeginning(), and sortCacheInfoByQueryMetric().

                                           {
     auto itr = cache_metrics_.find(device_identifier);
     CHECK(itr != cache_metrics_.end());
     return itr->second;
   }

Here is the caller graph for this function:

std::optional<size_t> CacheMetricTracker::getCurrentCacheSize ( DeviceIdentifier key ) const

inline

Definition at line 260 of file DataRecycler.h.

References current_cache_size_in_bytes_.

Referenced by canAddItem(), clearCacheMetricTracker(), and updateCurrentCacheSize().

                                                                       {
     auto same_hash = [key](auto itr) { return itr.first == key; };
     auto itr = std::find_if(current_cache_size_in_bytes_.cbegin(),
                             current_cache_size_in_bytes_.cend(),
                             same_hash);
     return itr == current_cache_size_in_bytes_.cend() ? std::nullopt
                                                       : std::make_optional(itr->second);
   }

Here is the caller graph for this function:

size_t CacheMetricTracker::getMaxCacheItemSize ( ) const

inline

Definition at line 395 of file DataRecycler.h.

References max_cache_item_size_.

395 { return max_cache_item_size_; }

CacheMetricTracker::max_cache_item_size_

size_t max_cache_item_size_

Definition: DataRecycler.h:410

size_t CacheMetricTracker::getTotalCacheSize ( ) const

inline

Definition at line 394 of file DataRecycler.h.

References total_cache_size_.

394 { return total_cache_size_; }

CacheMetricTracker::total_cache_size_

size_t total_cache_size_

Definition: DataRecycler.h:409

std::shared_ptr<CacheItemMetric> CacheMetricTracker::putNewCacheItemMetric	(	QueryPlanHash	key,
		DeviceIdentifier	device_identifier,
		size_t	mem_size,
		size_t	compute_time
	)

inline

Definition at line 269 of file DataRecycler.h.

References ADD, cache_metrics_, CHECK, getCacheItemMetricImpl(), REMOVE, removeCacheItemMetric(), and updateCurrentCacheSize().

                            {
     auto itr = cache_metrics_.find(device_identifier);
     CHECK(itr != cache_metrics_.end());
     if (auto cached_metric = getCacheItemMetricImpl(key, itr->second)) {
       if (cached_metric->getMemSize() != mem_size) {
         updateCurrentCacheSize(
             device_identifier, CacheUpdateAction::REMOVE, cached_metric->getMemSize());
         removeCacheItemMetric(key, device_identifier);
       } else {
         cached_metric->incRefCount();
         return cached_metric;
       }
     }
     auto cache_metric = std::make_shared<CacheItemMetric>(key, compute_time, mem_size);
     updateCurrentCacheSize(device_identifier, CacheUpdateAction::ADD, mem_size);
     // we add the item to cache after we create it during query runtime
     // so it is used at least once
     cache_metric->incRefCount();
     return itr->second.emplace_back(std::move(cache_metric));
   }

Here is the call graph for this function:

void CacheMetricTracker::removeCacheItemMetric	(	QueryPlanHash	key,
		DeviceIdentifier	device_identifier
	)

inline

Definition at line 294 of file DataRecycler.h.

References getCacheItemMetricItr(), and getCacheItemMetrics().

Referenced by putNewCacheItemMetric().

                                                                                     {
     auto& cache_metrics = getCacheItemMetrics(device_identifier);
     auto itr = getCacheItemMetricItr(key, cache_metrics);
     if (itr != cache_metrics.cend()) {
       cache_metrics.erase(itr);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void CacheMetricTracker::removeMetricFromBeginning	(	DeviceIdentifier	device_identifier,
		int	offset
	)

inline

Definition at line 302 of file DataRecycler.h.

References getCacheItemMetrics().

                                                                                  {
     auto metrics = getCacheItemMetrics(device_identifier);
     metrics.erase(metrics.begin(), metrics.begin() + offset);
   }

Here is the call graph for this function:

void CacheMetricTracker::setCurrentCacheSize	(	DeviceIdentifier	device_identifier,
		size_t	bytes
	)

inline

Definition at line 251 of file DataRecycler.h.

References CHECK, current_cache_size_in_bytes_, and total_cache_size_.

Referenced by updateCurrentCacheSize().

                                                                              {
     if (bytes > total_cache_size_) {
       return;
     }
     auto itr = current_cache_size_in_bytes_.find(device_identifier);
     CHECK(itr != current_cache_size_in_bytes_.end());
     itr->second = bytes;
   }

Here is the caller graph for this function:

void CacheMetricTracker::setMaxCacheItemSize ( size_t new_max_cache_item_size )

inline

Definition at line 401 of file DataRecycler.h.

References max_cache_item_size_.

Referenced by DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::setMaxCacheItemSize().

                                                            {
     if (new_max_cache_item_size > 0) {
       max_cache_item_size_ = new_max_cache_item_size;
     }
   }

Here is the caller graph for this function:

void CacheMetricTracker::setTotalCacheSize ( size_t new_total_cache_size )

inline

Definition at line 396 of file DataRecycler.h.

References total_cache_size_.

Referenced by DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::setTotalCacheSize().

                                                       {
     if (new_total_cache_size > 0) {
       total_cache_size_ = new_total_cache_size;
     }
   }

Here is the caller graph for this function:

void CacheMetricTracker::sortCacheInfoByQueryMetric ( DeviceIdentifier device_identifier )

inline

Definition at line 368 of file DataRecycler.h.

References getCacheItemMetrics(), NUM_METRIC_TYPE, and gpu_enabled::sort().

                                                                       {
     auto& metric_cache = getCacheItemMetrics(device_identifier);
     std::sort(metric_cache.begin(),
               metric_cache.end(),
               [](const std::shared_ptr<CacheItemMetric>& left,
                  const std::shared_ptr<CacheItemMetric>& right) {
                 auto& elem1_metrics = left->getMetrics();
                 auto& elem2_metrics = right->getMetrics();
                 for (size_t i = 0; i < CacheMetricType::NUM_METRIC_TYPE; ++i) {
                   if (elem1_metrics[i] != elem2_metrics[i]) {
                     return elem1_metrics[i] < elem2_metrics[i];
                   }
                 }
                 return false;
               });
   }

Here is the call graph for this function:

std::string CacheMetricTracker::toString ( ) const

inline

Definition at line 385 of file DataRecycler.h.

References current_cache_size_in_bytes_.

                              {
     std::ostringstream oss;
     oss << "Current memory consumption of caches for each device:\n";
     for (auto& kv : current_cache_size_in_bytes_) {
       oss << "\t\tDevice " << kv.first << " : " << kv.second << " bytes\n";
     }
     return oss.str();
   }

void CacheMetricTracker::updateCurrentCacheSize	(	DeviceIdentifier	device_identifier,
		CacheUpdateAction	action,
		size_t	size
	)

inline

Definition at line 354 of file DataRecycler.h.

References ADD, CHECK, CHECK_EQ, CHECK_LE, getCurrentCacheSize(), REMOVE, and setCurrentCacheSize().

Referenced by clearCacheMetricTracker(), and putNewCacheItemMetric().

                                            {
     auto current_cache_size = getCurrentCacheSize(device_identifier);
     CHECK(current_cache_size.has_value());
     if (action == CacheUpdateAction::ADD) {
       setCurrentCacheSize(device_identifier, current_cache_size.value() + size);
     } else {
       CHECK_EQ(action, CacheUpdateAction::REMOVE);
       CHECK_LE(size, *current_cache_size);
       setCurrentCacheSize(device_identifier, current_cache_size.value() - size);
     }
   }