lru_cache2.cpp File Reference

Implementation for [LRU Cache] (https://en.wikipedia.org/wiki/Cache_replacement_policies#:~:text=Least%20Recently%20Used%20(LRU)) More...

#include <cassert>
#include <cstdint>
#include <iostream>
#include <unordered_map>

Include dependency graph for lru_cache2.cpp:

Classes
class	others::Cache::D_Node< T >
	Node for a doubly linked list with data, prev and next pointers. More...
class	others::Cache::LRUCache< K, V >
	LRUCache. More...

Namespaces
namespace	others
	for vector
namespace	others::Cache
	Cache algorithm.

Functions
static void	test ()
	self test implementations
int	main ()
	main function

Detailed Description

Implementation for [LRU Cache] (https://en.wikipedia.org/wiki/Cache_replacement_policies#:~:text=Least%20Recently%20Used%20(LRU))

LRU discards the least recently used value. Data structures used - doubly linked list and unordered_map

unordered_map maps the key to the address of the node of the linked list. If the element is accessed, the element is moved to the beginning of the linked list.

When the cache is full, the last element in the linked list is popped.

Author

Karan Sharma

Function Documentation

main()

int main

(

void

)

main function

Returns

0 on exit

           {
    test();  // run the self test implementation
    return 0;
}

Here is the call graph for this function:

test()

static void test ( )

static

self test implementations

Returns

void

                   {
    others::Cache::LRUCache<int, int> cache(5);
 
    // test the initial state of the cache
    assert(cache.size() == 0);
    assert(cache.capacity() == 5);
    assert(cache.empty());
 
    // test insertion in the cache
    cache.put(1, 10);
    cache.put(-2, 20);
 
    // test the state of cache after inserting some items
    assert(cache.size() == 2);
    assert(cache.capacity() == 5);
    assert(!cache.empty());
 
    // test getting items from the cache
    assert(cache.get(1) == 10);
    assert(cache.get(-2) == 20);
 
    cache.put(-3, -30);
    cache.put(4, 40);
    cache.put(5, -50);
    cache.put(6, 60);
 
    // test the state after inserting more items than the capacity
    assert(cache.size() == 5);
    assert(cache.capacity() == 5);
    assert(!cache.empty());
 
    // fetching 1 throws runtime_error
    // as 1 was evicted being the least recently used
    // when 6 was added
    try {
        cache.get(1);
    } catch (const std::runtime_error &e) {
        assert(std::string(e.what()) == "key is not present in the cache");
    }
 
    // test retrieval of all items in the cache
    assert(cache.get(-2) == 20);
    assert(cache.get(-3) == -30);
    assert(cache.get(4) == 40);
    assert(cache.get(5) == -50);
    assert(cache.get(6) == 60);
 
    std::cout << "test - passed\n";
}

Here is the call graph for this function: