#include <OverlapsTuningParamRecycler.h>

Inheritance diagram for OverlapsTuningParamRecycler:

Collaboration diagram for OverlapsTuningParamRecycler:

Public Member Functions
	OverlapsTuningParamRecycler ()

	std::numeric_limits ()

	std::numeric_limits ()

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

Public Member Functions inherited from DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >
	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 < AutoTunerMetaInfo >	getItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::optional< EMPTY_META_INFO > 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 < AutoTunerMetaInfo > , EMPTY_META_INFO > >	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< EMPTY_META_INFO > meta_info=std::nullopt) const override

void	removeItemFromCache (QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier, std::lock_guard< std::mutex > &lock, std::optional< EMPTY_META_INFO > 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< EMPTY_META_INFO > meta_info=std::nullopt) override

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

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< AutoTunerMetaInfo >, EMPTY_META_INFO >
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 32 of file OverlapsTuningParamRecycler.h.

Constructor & Destructor Documentation

OverlapsTuningParamRecycler::OverlapsTuningParamRecycler ( )

inline

Definition at line 38 of file OverlapsTuningParamRecycler.h.

References OVERLAPS_AUTO_TUNER_PARAM.

39 : DataRecycler({CacheItemType::OVERLAPS_AUTO_TUNER_PARAM},

DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::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

OVERLAPS_AUTO_TUNER_PARAM

Definition: DataRecycler.h:44

Member Function Documentation

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

inlineoverrideprivatevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 87 of file OverlapsTuningParamRecycler.h.

References UNREACHABLE.

                                                                     {
     UNREACHABLE();
   }

void OverlapsTuningParamRecycler::clearCache ( )

overridevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 108 of file OverlapsTuningParamRecycler.cpp.

References DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), OVERLAPS_AUTO_TUNER_PARAM, PARAM_CACHE_DEVICE_IDENTIFIER, and VLOG.

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

Here is the call graph for this function:

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

overrideprivatevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 70 of file OverlapsTuningParamRecycler.cpp.

References CHECK_EQ, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_hashtable_cache, DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), and OVERLAPS_AUTO_TUNER_PARAM.

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

Here is the call graph for this function:

void OverlapsTuningParamRecycler::initCache ( )

inlineoverridevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 59 of file OverlapsTuningParamRecycler.h.

59 {}

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

overridevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 120 of file OverlapsTuningParamRecycler.cpp.

References CHECK_EQ, g_enable_data_recycler, g_use_hashtable_cache, DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCacheLock(), DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::markCachedItemAsDirtyImpl(), and OVERLAPS_AUTO_TUNER_PARAM.

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

Here is the call graph for this function:

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

overridevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 43 of file OverlapsTuningParamRecycler.cpp.

References CHECK_EQ, EMPTY_HASHED_PLAN_DAG_KEY, g_enable_data_recycler, g_use_hashtable_cache, DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemWithoutConsideringMetaInfo(), DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCacheLock(), DataRecyclerUtil::getDeviceIdentifierString(), OVERLAPS_AUTO_TUNER_PARAM, and VLOG.

                                             {
   if (!g_enable_data_recycler || !g_use_hashtable_cache ||
       key == EMPTY_HASHED_PLAN_DAG_KEY) {
     return;
   }
   CHECK_EQ(item_type, CacheItemType::OVERLAPS_AUTO_TUNER_PARAM);
   std::lock_guard<std::mutex> lock(getCacheLock());
   auto param_cache = getCachedItemContainer(item_type, device_identifier);
   auto cached_param = getCachedItemWithoutConsideringMetaInfo(
       key, item_type, device_identifier, *param_cache, lock);
   if (cached_param) {
     return;
   }
   param_cache->emplace_back(key, item, nullptr, meta_info);
   VLOG(1) << "[" << item_type << ", "
           << DataRecyclerUtil::getDeviceIdentifierString(device_identifier)
           << "] Put auto tuner parameters to cache (key: " << key << ")";
   return;
 }

Here is the call graph for this function:

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

overrideprivatevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 89 of file OverlapsTuningParamRecycler.cpp.

References DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), DataRecyclerUtil::getDeviceIdentifierString(), and VLOG.

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

Here is the call graph for this function:

OverlapsTuningParamRecycler::std::numeric_limits ( )

std::string OverlapsTuningParamRecycler::toString ( ) const

overridevirtual

Implements DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >.

Definition at line 136 of file OverlapsTuningParamRecycler.cpp.

References DataRecycler< std::optional< AutoTunerMetaInfo >, EMPTY_META_INFO >::getCachedItemContainer(), OVERLAPS_AUTO_TUNER_PARAM, and PARAM_CACHE_DEVICE_IDENTIFIER.

                                                       {
   std::ostringstream oss;
   oss << "A current status of the Overlaps Join Hashtable Tuning Parameter Recycler:\n";
   oss << "\t# cached parameters:\n";
   oss << "\t\tDevice" << PARAM_CACHE_DEVICE_IDENTIFIER << "\n";
   auto param_cache = getCachedItemContainer(CacheItemType::OVERLAPS_AUTO_TUNER_PARAM,
                                             PARAM_CACHE_DEVICE_IDENTIFIER);
   for (auto& cache_container : *param_cache) {
     oss << "\t\t\tCache_key: " << cache_container.key;
     if (cache_container.cached_item.has_value()) {
       oss << ", Max_hashtable_size: " << cache_container.cached_item->max_hashtable_size
           << ", Bucket_threshold: " << cache_container.cached_item->bucket_threshold
           << ", Bucket_sizes: " << ::toString(cache_container.cached_item->bucket_sizes)
           << "\n";
     } else {
       oss << ", Params info is not available\n";
     }
   }
   return oss.str();
 }

Here is the call graph for this function:

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

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

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation