Map/cache combination. More...

#include <TaggedCache.h>

Collaboration diagram for xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >:

[legend]

Classes
struct	Stats
class	KeyOnlyEntry
class	ValueEntry

Public Types
using	mutex_type = Mutex
using	key_type = Key
using	mapped_type = T
using	clock_type = beast::AbstractClock<std::chrono::steady_clock>
using	shared_weak_combo_pointer_type = SharedWeakUnionPointerType
using	shared_pointer_type = SharedPointerType
using	SweptPointersVector = std::vector<SharedWeakUnionPointerType>

Public Member Functions
	TaggedCache (std::string const &name, int size, clock_type::duration expiration, clock_type &clock, beast::Journal journal, beast::insight::Collector::ptr const &collector=beast::insight::NullCollector::make())
clock_type &	clock ()
	Return the clock associated with the cache.
std::size_t	size () const
	Returns the number of items in the container.
int	getCacheSize () const
int	getTrackSize () const
float	getHitRate ()
void	clear ()
void	reset ()
template<class KeyComparable>
bool	touchIfExists (KeyComparable const &key)
	Refresh the last access time on a key if present.
void	sweep ()
bool	del (key_type const &key, bool valid)
template<class Callback>
bool	canonicalize (key_type const &key, SharedPointerType &data, Callback &&replaceCallback)
	Replace aliased objects with originals.
bool	canonicalizeReplaceCache (key_type const &key, SharedPointerType const &data)
	Insert/update the canonical entry for key, always replacing the cached value with data.
bool	canonicalizeReplaceClient (key_type const &key, SharedPointerType &data)
	Insert the canonical entry for key, keeping any existing cached value.
SharedPointerType	fetch (key_type const &key)
template<class ReturnType = bool>
auto	insert (key_type const &key, T const &value) -> ReturnType requires(!IsKeyCache)
	Insert the element into the container.
template<class ReturnType = bool> requires IsKeyCache
auto	insert (key_type const &key) -> ReturnType
bool	retrieve (key_type const &key, T &data)
mutex_type &	peekMutex ()
std::vector< key_type >	getKeys () const
double	rate () const
	Returns the fraction of cache hits.
template<class Handler>
SharedPointerType	fetch (key_type const &digest, Handler const &h)
	Fetch an item from the cache.

Private Types
template<typename Policy>
using	CanonicalizeClientPointerType
using	Entry = std::conditional_t<IsKeyCache, KeyOnlyEntry, ValueEntry>
using	KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>
using	KeyValueCacheType = hardened_partitioned_hash_map<key_type, ValueEntry, Hash, KeyEqual>
using	cache_type = hardened_partitioned_hash_map<key_type, Entry, Hash, KeyEqual>

Private Member Functions
template<class Policy, class Callback = std::nullptr_t>
bool	canonicalizeImpl (key_type const &key, CanonicalizeClientPointerType< Policy > data, Policy policy, Callback &&replaceCallback=nullptr)
	Shared implementation of the canonicalize family.
SharedPointerType	initialFetch (key_type const &key, std::scoped_lock< mutex_type > const &l)
void	collectMetrics ()
std::thread	sweepHelper (clock_type::time_point const &whenExpire, clock_type::time_point const &now, KeyValueCacheType::map_type &partition, SweptPointersVector &stuffToSweep, std::atomic< int > &allRemovals, std::scoped_lock< std::recursive_mutex > const &)
std::thread	sweepHelper (clock_type::time_point const &whenExpire, clock_type::time_point const &now, KeyOnlyCacheType::map_type &partition, SweptPointersVector &, std::atomic< int > &allRemovals, std::scoped_lock< std::recursive_mutex > const &)

Private Attributes
beast::Journal	journal_
clock_type &	clock_
Stats	stats_
mutex_type	mutex_
std::string	name_
int const	targetSize_
clock_type::duration const	targetAge_
int	cacheCount_ {0}
cache_type	cache_
std::uint64_t	hits_ {0}
std::uint64_t	misses_ {0}

Detailed Description

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>
class xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >

Map/cache combination.

This class implements a cache and a map. The cache keeps objects alive in the map. The map allows multiple code paths that reference objects with the same tag to get the same actual object.

So long as data is in the cache, it will stay in memory. If it stays in memory even after it is ejected from the cache, the map will track it.

Note: Callers must not modify data objects that are stored in the cache unless they hold their own lock over all cache operations.

Definition at line 66 of file TaggedCache.h.

Member Typedef Documentation

◆ mutex_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::mutex_type = Mutex

Definition at line 69 of file TaggedCache.h.

◆ key_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::key_type = Key

Definition at line 70 of file TaggedCache.h.

◆ mapped_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::mapped_type = T

Definition at line 71 of file TaggedCache.h.

◆ clock_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::clock_type = beast::AbstractClock<std::chrono::steady_clock>

Definition at line 72 of file TaggedCache.h.

◆ shared_weak_combo_pointer_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::shared_weak_combo_pointer_type = SharedWeakUnionPointerType

Definition at line 73 of file TaggedCache.h.

◆ shared_pointer_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::shared_pointer_type = SharedPointerType

Definition at line 74 of file TaggedCache.h.

◆ SweptPointersVector

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::SweptPointersVector = std::vector<SharedWeakUnionPointerType>

Definition at line 121 of file TaggedCache.h.

◆ CanonicalizeClientPointerType

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<typename Policy>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::CanonicalizeClientPointerType

private

Initial value:

std::conditional_t<
       std::is_same_v<detail::ReplaceCached, Policy>,
       SharedPointerType const&,
       SharedPointerType&>

Definition at line 134 of file TaggedCache.h.

◆ Entry

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::Entry = std::conditional_t<IsKeyCache, KeyOnlyEntry, ValueEntry>

private

Definition at line 352 of file TaggedCache.h.

◆ KeyOnlyCacheType

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>

private

Definition at line 354 of file TaggedCache.h.

◆ KeyValueCacheType

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::KeyValueCacheType = hardened_partitioned_hash_map<key_type, ValueEntry, Hash, KeyEqual>

private

Definition at line 356 of file TaggedCache.h.

◆ cache_type

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

using xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::cache_type = hardened_partitioned_hash_map<key_type, Entry, Hash, KeyEqual>

private

Definition at line 358 of file TaggedCache.h.

Constructor & Destructor Documentation

◆ TaggedCache()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::TaggedCache	(	std::string const &	name,
		int	size,
		clock_type::duration	expiration,
		clock_type &	clock,
		beast::Journal	journal,
		beast::insight::Collector::ptr const &	collector = beast::insight::NullCollector::make() )

Member Function Documentation

◆ clock()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

clock_type & xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::clock ( )

Return the clock associated with the cache.

◆ size()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::size_t xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::size ( ) const

Returns the number of items in the container.

◆ getCacheSize()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

int xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::getCacheSize ( ) const

◆ getTrackSize()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

int xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::getTrackSize ( ) const

◆ getHitRate()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

float xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::getHitRate ( )

◆ clear()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

void xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::clear ( )

◆ reset()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

void xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::reset ( )

◆ touchIfExists()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class KeyComparable>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::touchIfExists ( KeyComparable const & key )

Refresh the last access time on a key if present.

Returns: true If the key was found.

◆ sweep()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

void xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::sweep ( )

◆ del()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::del	(	key_type const &	key,
		bool	valid )

◆ canonicalizeImpl()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class Policy, class Callback = std::nullptr_t>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::canonicalizeImpl	(	key_type const &	key,
		CanonicalizeClientPointerType< Policy >	data,
		Policy	policy,
		Callback &&	replaceCallback = nullptr )

private

Shared implementation of the canonicalize family.

policy selects how a collision is resolved when key already exists: detail::ReplaceCached, detail::ReplaceClient or detail::ReplaceDynamically. For ReplaceDynamically replaceCallback is invoked with the existing strong pointer and returns whether to replace the cached value with data; for the tag policies it is unused.

◆ canonicalize()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class Callback>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::canonicalize	(	key_type const &	key,
		SharedPointerType &	data,
		Callback &&	replaceCallback )

Replace aliased objects with originals.

Due to concurrency it is possible for two separate objects with the same content and referring to the same unique "thing" to exist. This routine eliminates the duplicate and performs a replacement on the callers shared pointer if needed.

replaceCallback is a callable taking the existing strong pointer and returning whether to replace the cached value with data (true) or to keep the cached value and write it back into data (false). Because the write-back case mutates data, data must be writable.

Parameters

key	The key corresponding to the object
data	A shared pointer to the data corresponding to the object.
replaceCallback	A callable (existing strong pointer -> bool).

Returns: true if an existing live entry was found and used; false if a new entry was inserted or an expired tracked entry was re-cached.

◆ canonicalizeReplaceCache()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::canonicalizeReplaceCache	(	key_type const &	key,
		SharedPointerType const &	data )

Insert/update the canonical entry for key, always replacing the cached value with data.

If an entry already exists for key, the cached value is unconditionally replaced with data; otherwise data is inserted. data is never written back, so it may be const.

Parameters

key	The key corresponding to the object.
data	A shared pointer to the data corresponding to the object.

Returns: true if an existing live entry was found and used; false if a new entry was inserted or an expired tracked entry was re-cached.

◆ canonicalizeReplaceClient()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::canonicalizeReplaceClient	(	key_type const &	key,
		SharedPointerType &	data )

Insert the canonical entry for key, keeping any existing cached value.

If an entry already exists for key, the cached value is kept and written back into data so the caller ends up with the canonical object; otherwise data is inserted. Because data may be overwritten it must be writable.

Parameters

key	The key corresponding to the object.
data	A shared pointer to the data corresponding to the object; updated to the canonical value when one already exists.

Returns: true if an existing live entry was found and used; false if a new entry was inserted or an expired tracked entry was re-cached.

◆ fetch() [1/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

SharedPointerType xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::fetch ( key_type const & key )

◆ insert() [1/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class ReturnType = bool>

auto xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::insert	(	key_type const &	key,
		T const &	value ) -> ReturnType requires(!IsKeyCache)

Insert the element into the container.

If the key already exists, nothing happens.

Returns: true If the element was inserted

◆ insert() [2/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class ReturnType = bool>
requires IsKeyCache

auto xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::insert ( key_type const & key ) -> ReturnType

◆ retrieve()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

bool xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::retrieve	(	key_type const &	key,
		T &	data )

◆ peekMutex()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

mutex_type & xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::peekMutex ( )

◆ getKeys()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::vector< key_type > xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::getKeys ( ) const

◆ rate()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

double xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::rate ( ) const

Returns the fraction of cache hits.

◆ fetch() [2/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

template<class Handler>

SharedPointerType xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::fetch	(	key_type const &	digest,
		Handler const &	h )

Fetch an item from the cache.

If the digest was not found, Handler will be called with this signature: SLE::const_pointer(void)

◆ initialFetch()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

SharedPointerType xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::initialFetch	(	key_type const &	key,
		std::scoped_lock< mutex_type > const &	l )

private

◆ collectMetrics()

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

void xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::collectMetrics ( )

private

◆ sweepHelper() [1/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::thread xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::sweepHelper	(	clock_type::time_point const &	whenExpire,
		clock_type::time_point const &	now,
		KeyValueCacheType::map_type &	partition,
		SweptPointersVector &	stuffToSweep,
		std::atomic< int > &	allRemovals,
		std::scoped_lock< std::recursive_mutex > const &	)

nodiscardprivate

◆ sweepHelper() [2/2]

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::thread xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::sweepHelper	(	clock_type::time_point const &	whenExpire,
		clock_type::time_point const &	now,
		KeyOnlyCacheType::map_type &	partition,
		SweptPointersVector &	,
		std::atomic< int > &	allRemovals,
		std::scoped_lock< std::recursive_mutex > const &	)

nodiscardprivate

Member Data Documentation

◆ journal_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

beast::Journal xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::journal_

private

Definition at line 378 of file TaggedCache.h.

◆ clock_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

clock_type& xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::clock_

private

Definition at line 379 of file TaggedCache.h.

◆ stats_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

Stats xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::stats_

private

Definition at line 380 of file TaggedCache.h.

◆ mutex_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

mutex_type xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::mutex_

mutableprivate

Definition at line 382 of file TaggedCache.h.

◆ name_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::string xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::name_

private

Definition at line 385 of file TaggedCache.h.

◆ targetSize_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

int const xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::targetSize_

private

Definition at line 388 of file TaggedCache.h.

◆ targetAge_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

clock_type::duration const xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::targetAge_

private

Definition at line 391 of file TaggedCache.h.

◆ cacheCount_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

int xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::cacheCount_ {0}

private

Definition at line 394 of file TaggedCache.h.

◆ cache_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

cache_type xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::cache_

private

Definition at line 395 of file TaggedCache.h.

◆ hits_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::uint64_t xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::hits_ {0}

private

Definition at line 396 of file TaggedCache.h.

◆ misses_

template<class Key, class T, bool IsKeyCache = false, class SharedWeakUnionPointerType = SharedWeakCachePointer<T>, class SharedPointerType = std::shared_ptr<T>, class Hash = HardenedHash<>, class KeyEqual = std::equal_to<Key>, class Mutex = std::recursive_mutex>

std::uint64_t xrpl::TaggedCache< Key, T, IsKeyCache, SharedWeakUnionPointerType, SharedPointerType, Hash, KeyEqual, Mutex >::misses_ {0}

private

Definition at line 397 of file TaggedCache.h.

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ mutex_type

◆ key_type

◆ mapped_type

◆ clock_type

◆ shared_weak_combo_pointer_type

◆ shared_pointer_type

◆ SweptPointersVector

◆ CanonicalizeClientPointerType

◆ Entry

◆ KeyOnlyCacheType

◆ KeyValueCacheType

◆ cache_type

Constructor & Destructor Documentation

◆ TaggedCache()

Member Function Documentation

◆ clock()

◆ size()

◆ getCacheSize()

◆ getTrackSize()

◆ getHitRate()

◆ clear()

◆ reset()

◆ touchIfExists()

◆ sweep()

◆ del()

◆ canonicalizeImpl()

◆ canonicalize()

◆ canonicalizeReplaceCache()

◆ canonicalizeReplaceClient()

◆ fetch() [1/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ retrieve()

◆ peekMutex()

◆ getKeys()

◆ rate()

◆ fetch() [2/2]

◆ initialFetch()

◆ collectMetrics()

◆ sweepHelper() [1/2]

◆ sweepHelper() [2/2]

Member Data Documentation

◆ journal_

◆ clock_

◆ stats_

◆ mutex_

◆ name_

◆ targetSize_

◆ targetAge_

◆ cacheCount_

◆ cache_

◆ hits_

◆ misses_