public:

explicit LRUCache(size_t max_fusions) : max_fusions_(max_fusions) {

NVF_ERROR_GT(max_fusions_, 0, "Max fusions must be greater than 0");

}

//! Copy and Assignment of the LRUCache is not supported

LRUCache(const LRUCache&) = delete;

LRUCache& operator=(const LRUCache&) = delete;

// Create a FusionExecutorCache for given fusion.

// If the fusion is already in the cache, it will be moved to the front of the

// cache and returned immediately.

// If the cache is full, the least recently used fusion will be evicted.

FusionExecutorCache* cacheCompile(std::unique_ptr<Fusion> fusion);

// Print stats about LRU Cache

std::string stats() const;

// Get the number of fusions cached

size_t numFusions() const {

std::lock_guard<std::mutex> guard(lru_mutex_);

return items_list.size();

}

private:

// Item is a tuple of key, value, and visits per key

struct Item {

Fusion* fusion;

std::unique_ptr<FusionExecutorCache> executor_cache;

size_t visits;

};

// Custom Hasher Functor for Fusion

struct FusionHasher {

size_t operator()(const Fusion* fusion) const {

return fusion->hash();

}

};

// Custom Equality Functor for Fusion

struct FusionEqualTo {

bool operator()(const Fusion* lhs, const Fusion* rhs) const {

return lhs->sameDefinition(*rhs);

}

};

// Cumulative number of fusions compiled

inline size_t numFusionsCompiled() const {

return num_cache_lookups_ - num_cache_hits_;

}

// The list stores key-value pairs to maintain the order of use.

// Front of the list is the most recently used.

std::list<Item> items_list;

// TODO Replace std::unordered_map with absl::flat_hash_map

// Reference: Use https://abseil.io/docs/cpp/guides/container

// The map provides O(1) access to list nodes.

// It stores keys and iterators to the corresponding pairs in the list.

std::unordered_map<

Fusion*,

typename std::list<Item>::iterator,

FusionHasher,

FusionEqualTo>

items_map;

//! The max allowed number of fusions in the cache

size_t max_fusions_ = 0;

// Number of visits to the cache

size_t num_cache_lookups_ = 0;

// Number of cache hits

size_t num_cache_hits_ = 0;

// Mutex for multi-threaded safety

mutable std::mutex lru_mutex_;