duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual > Class Template Reference

Collaboration diagram for duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >:

Classes
struct	Entry

Public Types
using	key_type = Key
using	mapped_type = shared_ptr< Val >
using	hasher = KeyHash
using	key_equal = KeyEqual

Public Member Functions
	SharedLruCache (idx_t max_total_weight_p)
	SharedLruCache (const SharedLruCache &)=delete
SharedLruCache &	operator= (const SharedLruCache &)=delete
template<typename... Types>
void	Put (Key key, shared_ptr< Val > value, Types... constructor_args)
bool	Delete (const Key &key)
shared_ptr< Val >	Get (const Key &key)
void	Clear ()
idx_t	EvictToReduceAtLeast (idx_t target_weight)
idx_t	Capacity () const
idx_t	CurrentTotalWeight () const
size_t	Size () const
bool	IsEmpty () const

Private Types
using	EntryMap = unordered_map< Key, Entry, KeyHash, KeyEqual >

Private Member Functions
void	DeleteImpl (typename EntryMap::iterator iter)
void	EvictIfNeeded (idx_t required_weight)

Private Attributes
const idx_t	max_total_weight
idx_t	current_total_weight
EntryMap	entry_map
list< Key >	lru_list

Constructor & Destructor Documentation

SharedLruCache()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::SharedLruCache ( idx_t  max_total_weight_p )

inlineexplicit

                                                      : max_total_weight(max_total_weight_p), current_total_weight(0) {
    }

Member Function Documentation

Put()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

template<typename... Types>

void duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Put ( Key  key, shared_ptr< Val >  value, Types...  constructor_args  )

inline

                                                                        {
        // Remove existing entry if present
        auto existing_it = entry_map.find(key);
        if (existing_it != entry_map.end()) {
            DeleteImpl(existing_it);
        }
 
        auto payload = make_uniq<Payload>(std::forward<Types>(constructor_args)...);
        auto payload_weight = payload->GetWeight();
 
        // Evict entries if needed to make room
        if (max_total_weight > 0 && payload_weight > 0) {
            EvictIfNeeded(payload_weight);
        }
 
        // Add new entry
        lru_list.emplace_front(key);
        Entry new_entry;
        new_entry.value = std::move(value);
        new_entry.lru_iterator = lru_list.begin();
        new_entry.payload = std::move(payload);
        new_entry.payload_weight = payload_weight;
 
        entry_map[std::move(key)] = std::move(new_entry);
        current_total_weight += payload_weight;
    }

Delete()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

bool duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Delete ( const Key &  key )

inline

                                {
        auto it = entry_map.find(key);
        if (it == entry_map.end()) {
            return false;
        }
        DeleteImpl(it);
        return true;
    }

Get()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

shared_ptr< Val > duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Get ( const Key &  key )

inline

                                        {
        auto entry_map_iter = entry_map.find(key);
        if (entry_map_iter == entry_map.end()) {
            return nullptr;
        }
 
        // Move to front, which indicates most recently used.
        lru_list.splice(lru_list.begin(), lru_list, entry_map_iter->second.lru_iterator);
        return entry_map_iter->second.value;
    }

Clear()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

void duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Clear ( )

inline

                 {
        entry_map.clear();
        lru_list.clear();
        current_total_weight = 0;
    }

EvictToReduceAtLeast()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

idx_t duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::EvictToReduceAtLeast ( idx_t  target_weight )

inline

                                                    {
        idx_t freed = 0;
        while (!lru_list.empty() && freed < target_weight) {
            const auto &stale_key = lru_list.back();
            auto stale_it = entry_map.find(stale_key);
            D_ASSERT(stale_it != entry_map.end());
            freed += stale_it->second.payload_weight;
            DeleteImpl(stale_it);
        }
        return freed;
    }

Capacity()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

idx_t duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Capacity ( ) const

inline

                           {
        return max_total_weight;
    }

CurrentTotalWeight()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

idx_t duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::CurrentTotalWeight ( ) const

inline

                                     {
        return current_total_weight;
    }

Size()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

size_t duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::Size ( ) const

inline

                        {
        return entry_map.size();
    }

IsEmpty()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

bool duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::IsEmpty ( ) const

inline

                         {
        return entry_map.empty();
    }

DeleteImpl()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

void duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::DeleteImpl ( typename EntryMap::iterator  iter )

inlineprivate

                                                    {
        current_total_weight -= iter->second.payload_weight;
        D_ASSERT(current_total_weight >= 0);
        lru_list.erase(iter->second.lru_iterator);
        entry_map.erase(iter);
    }

EvictIfNeeded()

template<typename Key , typename Val , typename Payload = DefaultPayload, typename KeyHash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>

void duckdb::SharedLruCache< Key, Val, Payload, KeyHash, KeyEqual >::EvictIfNeeded ( idx_t  required_weight )

inlineprivate

                                              {
        if (max_total_weight == 0) {
            return;
        }
 
        // Evict LRU entries until we have enough space
        while (!lru_list.empty() && (current_total_weight + required_weight > max_total_weight)) {
            const auto &stale_key = lru_list.back();
            auto stale_it = entry_map.find(stale_key);
            if (stale_it != entry_map.end()) {
                DeleteImpl(stale_it);
            } else {
                // Should not happen, but be defensive
                lru_list.pop_back();
            }
        }
    }

---

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

• external/duckdb/duckdb.cpp