#include <DataRecycler.h>

Public Types
using	CachedItemContainer = std::vector< CachedItem< CACHED_ITEM_TYPE, META_INFO_TYPE >>

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 >

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

virtual	~DataRecycler ()=default

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

virtual void	putItemToCache (QueryPlanHash key, CACHED_ITEM_TYPE item_ptr, CacheItemType item_type, DeviceIdentifier device_identifier, size_t item_size, size_t compute_time, std::optional< META_INFO_TYPE > meta_info=std::nullopt)=0

virtual void	initCache ()=0

virtual void	clearCache ()=0

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

void	markCachedItemAsDirtyImpl (QueryPlanHash key, CachedItemContainer &m) const

bool	isCachedItemDirty (QueryPlanHash key, CachedItemContainer &m) const

virtual std::string	toString () const =0

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

std::optional< CachedItem < CACHED_ITEM_TYPE, META_INFO_TYPE > >	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)

Protected Member Functions
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

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

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

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

Private Attributes
std::unordered_set< CacheItemType >	cache_item_types_

PerTypeCacheMetricTracker	metric_tracker_

PerTypeCacheItemContainer	cached_items_container_

std::mutex	cache_lock_

Detailed Description

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>
class DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >

Definition at line 451 of file DataRecycler.h.

Member Typedef Documentation

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

using DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::CachedItemContainer = std::vector<CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>>

Definition at line 453 of file DataRecycler.h.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

Definition at line 455 of file DataRecycler.h.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

Definition at line 457 of file DataRecycler.h.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

using DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::PerTypeCacheMetricTracker = std::unordered_map<CacheItemType, CacheMetricTracker>

Definition at line 458 of file DataRecycler.h.

Constructor & Destructor Documentation

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

inline

Definition at line 460 of file DataRecycler.h.

                              {
     for (auto& item_type : item_types) {
       cache_item_types_.insert(item_type);
       metric_tracker_.emplace(
           item_type,
           CacheMetricTracker(item_type, total_cache_size, max_item_size, num_gpus));
       auto item_container = std::make_shared<PerDeviceCacheItemContainer>();
       for (int gpu_device_identifier = num_gpus; gpu_device_identifier >= 1;
            --gpu_device_identifier) {
         item_container->emplace(gpu_device_identifier,
                                 std::make_shared<CachedItemContainer>());
       }
       item_container->emplace(DataRecyclerUtil::CPU_DEVICE_IDENTIFIER,
                               std::make_shared<CachedItemContainer>());
       cached_items_container_.emplace(item_type, item_container);
     }
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::~DataRecycler ( )

virtualdefault

Member Function Documentation

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

privatepure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::clearCache ( )

pure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

inline

Definition at line 530 of file DataRecycler.h.

Referenced by DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCurrentNumCachedItems(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCurrentNumCleanCachedItems(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCurrentNumDirtyCachedItems(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::removeCachedItemFromBeginning(), and DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::sortCacheContainerByQueryMetric().

                                                 {
     auto item_type_container_itr = cached_items_container_.find(item_type);
     if (item_type_container_itr != cached_items_container_.end()) {
       auto device_type_container_itr =
           item_type_container_itr->second->find(device_identifier);
       return device_type_container_itr != item_type_container_itr->second->end()
                  ? device_type_container_itr->second
                  : nullptr;
     }
     return nullptr;
   }

Here is the caller graph for this function:

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

inline

Definition at line 600 of file DataRecycler.h.

                                                                                 {
     std::lock_guard<std::mutex> lock(cache_lock_);
     auto cache_metric_tracker = getMetricTracker(item_type);
     return cache_metric_tracker.getCacheItemMetric(key, device_identifier);
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

inline

Definition at line 545 of file DataRecycler.h.

                                                                          {
     auto candidate_it = std::find_if(
         m.begin(),
         m.end(),
         [&key](const CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>& cached_item) {
           return cached_item.key == key;
         });
     if (candidate_it != m.end()) {
       if (candidate_it->isDirty()) {
         removeItemFromCache(
             key, item_type, device_identifier, lock, candidate_it->meta_info);
         return std::nullopt;
       }
       return *candidate_it;
     }
     return std::nullopt;
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

std::unordered_set<CacheItemType> const& DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCacheItemType ( ) const

inlineprotected

Definition at line 666 of file DataRecycler.h.

                                                                   {
     return cache_item_types_;
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

std::mutex& DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCacheLock ( ) const

inlineprotected

Definition at line 654 of file DataRecycler.h.

654 { return cache_lock_; }

DataRecycler::cache_lock_

std::mutex cache_lock_

Definition: DataRecycler.h:708

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

size_t DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCurrentCacheSizeForDevice	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)		const

inline

Definition at line 592 of file DataRecycler.h.

                                                                                 {
     std::lock_guard<std::mutex> lock(cache_lock_);
     auto metric_tracker = getMetricTracker(item_type);
     auto current_size_opt = metric_tracker.getCurrentCacheSize(device_identifier);
     return current_size_opt ? current_size_opt.value() : 0;
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

size_t DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCurrentNumCachedItems	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)		const

inline

Definition at line 567 of file DataRecycler.h.

                                                                             {
     std::lock_guard<std::mutex> lock(cache_lock_);
     auto container = getCachedItemContainer(item_type, device_identifier);
     return container ? container->size() : 0;
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

size_t DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCurrentNumCleanCachedItems	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)		const

inline

Definition at line 583 of file DataRecycler.h.

                                                                                  {
     std::lock_guard<std::mutex> lock(cache_lock_);
     auto container = getCachedItemContainer(item_type, device_identifier);
     return std::count_if(container->begin(),
                          container->end(),
                          [](const auto& cached_item) { return !cached_item.isDirty(); });
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

size_t DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getCurrentNumDirtyCachedItems	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)		const

inline

Definition at line 574 of file DataRecycler.h.

                                                                                  {
     std::lock_guard<std::mutex> lock(cache_lock_);
     auto container = getCachedItemContainer(item_type, device_identifier);
     return std::count_if(container->begin(),
                          container->end(),
                          [](const auto& cached_item) { return cached_item.isDirty(); });
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

PerTypeCacheItemContainer const& DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getItemCache ( ) const

inlineprotected

Definition at line 670 of file DataRecycler.h.

                                                         {
     return cached_items_container_;
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual CACHED_ITEM_TYPE DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getItemFromCache	(	QueryPlanHash	key,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		std::optional< META_INFO_TYPE >	meta_info = `std::nullopt`
	)

pure virtual

Implemented in ChunkMetadataRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

CacheMetricTracker& DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getMetricTracker ( CacheItemType item_type )

inlineprotected

Definition at line 656 of file DataRecycler.h.

Referenced by DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCachedItemMetric(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCurrentCacheSizeForDevice(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getMetricTracker(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::setMaxCacheItemSize(), and DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::setTotalCacheSize().

                                                                 {
     auto metric_iter = metric_tracker_.find(item_type);
     CHECK(metric_iter != metric_tracker_.end());
     return metric_iter->second;
   }

Here is the caller graph for this function:

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

CacheMetricTracker const& DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::getMetricTracker ( CacheItemType item_type ) const

inlineprotected

Definition at line 662 of file DataRecycler.h.

                                                                             {
     return const_cast<DataRecycler*>(this)->getMetricTracker(item_type);
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

privatepure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::initCache ( )

pure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

bool DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::isCachedItemDirty	(	QueryPlanHash	key,
		CachedItemContainer &	m
	)		const

inline

Definition at line 518 of file DataRecycler.h.

                                                                           {
     auto candidate_it = std::find_if(
         m.begin(),
         m.end(),
         [&key](const CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>& cached_item) {
           return cached_item.key == key;
         });
     return candidate_it != m.end() && candidate_it->isDirty();
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::markCachedItemAsDirty	(	size_t	table_key,
		std::unordered_set< QueryPlanHash > &	key_set,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)

pure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::markCachedItemAsDirtyImpl	(	QueryPlanHash	key,
		CachedItemContainer &	m
	)		const

inline

Definition at line 506 of file DataRecycler.h.

                                                                                   {
     auto candidate_it = std::find_if(
         m.begin(),
         m.end(),
         [&key](const CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>& cached_item) {
           return cached_item.key == key;
         });
     if (candidate_it != m.end()) {
       candidate_it->setDirty();
     }
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::putItemToCache	(	QueryPlanHash	key,
		CACHED_ITEM_TYPE	item_ptr,
		CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		size_t	item_size,
		size_t	compute_time,
		std::optional< META_INFO_TYPE >	meta_info = `std::nullopt`
	)

pure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::removeCachedItemFromBeginning	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier,
		int	offset
	)

inlineprotected

Definition at line 623 of file DataRecycler.h.

                                                  {
     // it removes cached items located from `idx 0` to `offset`
     // so, call this function after sorting the cached items container vec
     // and we should call this function under the proper locking scheme
     auto container = getCachedItemContainer(item_type, device_identifier);
     CHECK(container);
     container->erase(container->begin(), container->begin() + offset);
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

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

privatepure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

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

Here is the caller graph for this function:

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::setMaxCacheItemSize	(	CacheItemType	item_type,
		size_t	new_max_cache_item_size
	)

inline

Definition at line 615 of file DataRecycler.h.

                                                                                     {
     if (new_max_cache_item_size > 0) {
       std::lock_guard<std::mutex> lock(cache_lock_);
       getMetricTracker(item_type).setMaxCacheItemSize(new_max_cache_item_size);
     }
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::setTotalCacheSize	(	CacheItemType	item_type,
		size_t	new_total_cache_size
	)

inline

Definition at line 608 of file DataRecycler.h.

                                                                                {
     if (new_total_cache_size > 0) {
       std::lock_guard<std::mutex> lock(cache_lock_);
       getMetricTracker(item_type).setTotalCacheSize(new_total_cache_size);
     }
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

void DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::sortCacheContainerByQueryMetric	(	CacheItemType	item_type,
		DeviceIdentifier	device_identifier
	)

inlineprotected

Definition at line 634 of file DataRecycler.h.

                                                                            {
     // should call this function under the proper locking scheme
     auto container = getCachedItemContainer(item_type, device_identifier);
     CHECK(container);
     std::sort(container->begin(),
               container->end(),
               [](const CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>& left,
                  const CachedItem<CACHED_ITEM_TYPE, META_INFO_TYPE>& right) {
                 auto& left_metrics = left.item_metric->getMetrics();
                 auto& right_metrics = right.item_metric->getMetrics();
                 for (size_t i = 0; i < CacheMetricType::NUM_METRIC_TYPE; ++i) {
                   if (left_metrics[i] != right_metrics[i]) {
                     return left_metrics[i] < right_metrics[i];
                   }
                 }
                 return false;
               });
   }

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

virtual std::string DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::toString ( ) const

pure virtual

Implemented in HashtableRecycler, ResultSetRecycler, ChunkMetadataRecycler, OverlapsTuningParamRecycler, and HashingSchemeRecycler.

Member Data Documentation

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

std::unordered_set<CacheItemType> DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::cache_item_types_

private

Definition at line 700 of file DataRecycler.h.

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

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

std::mutex DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::cache_lock_

mutableprivate

Definition at line 708 of file DataRecycler.h.

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

PerTypeCacheItemContainer DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::cached_items_container_

private

Definition at line 706 of file DataRecycler.h.

Referenced by DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::DataRecycler(), DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getCachedItemContainer(), and DataRecycler< std::optional< HashType >, EMPTY_META_INFO >::getItemCache().

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>

PerTypeCacheMetricTracker DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >::metric_tracker_

private

Definition at line 703 of file DataRecycler.h.

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

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

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

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE> class DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename CACHED_ITEM_TYPE, typename META_INFO_TYPE>
class DataRecycler< CACHED_ITEM_TYPE, META_INFO_TYPE >