using MyKeyType = std::string;
using MyValueType = MinecraftChunk;

LruClockCache<MyKeyType,MyValueType> cache(1024*5,[&](MyKeyType key){ 
  // cache miss (read)
  // access data-store (network, hdd, graphics card, anything that is slower than RAM or higher-latency than RAM-latency x2)
  return readChunkFromHDD(key);
  },[&](MyKeyType key,MyValueType value){ 
  
  // cache miss (write)
  // access data-store
  writeChunkToHDD(key,value);
});

// cache handles all cace-miss functions automatically
MinecraftChunk chunk = cache.get("world coordinates 1500 35 2000");

// cache handles all cace-miss functions automatically
cache.set("world coordinates 1502 35 1999",chunk);

cache.flush(); // clears all pending-writes in the cache and writes to backing-store

int main()
{
	std::vector<int> data(1024*1024); // simulating a backing-store
    
	MultiLevelCache<int,int> cache(
		64*1024 /* direct-mapped L1 cache elements */,
		256,1024 /* n-way set-associative (LRU approximation) L2 cache elements */,
		[&](int key){ return data[key]; } /* cache-miss function to get data from backingstore into cache */,
		[&](int key, int value){ data[key]=value; } /* cache-miss function to set data on backging-store during eviction */
	);
	cache.set(5,10); // this is single-thread example, sets value 10 at key position of 5
	cache.flush(); // writes all latest bits of data to backing-store
	std::cout<<data[5]<<std::endl;
	auto val = cache.getThreadSafe(5); // this is thread-safe from any number of threads
	cache.setThreadSafe(10,val); //    thread-safe, any number of threads
	return 0;
}

int main()
{
	std::vector<int> data(1000000); // backing-store simulation
	
	// L1 cache = direct mapped 128 elements
	// L2 cache = fully associative 128*1024 elements
	// similar cache-miss functions with MultiLevelCache
	AsyncCache<int,int> cache(128,128*1024,[&](int key){ return data[key]; },[&](int key, int value){ data[key]=value; });
	
	int val;
	
	// immediately returns, cache runs asynchronously to serve in a dedicated thread
	int slot = cache.setAsync(5,100); // or int slot = omp_get_thread_num(); cache.setAsync(5,100,slot);
	
	// immediately returns, any slot id can be used but a thread should use its own unique slot id on all operations for maximum performance
	cache.getAsync(5,&val,slot);	
	
	std::cout<<data[5]<<" "<<val<<std::endl;
	
	// waits for completion of operations issued into slot
	cache.barrier(slot); 
	
	std::cout<<data[5]<<" "<<val<<std::endl;
	
	// writes all dirty data to backing-store and waits for completion
	cache.flush(); 
	
	std::cout<<data[5]<<" "<<val<<std::endl;
	return 0;
}

// simulating a backing-store
std::vector<int> backingStore(10000000);

// this is to be used by multi-level cache constructor and must implement getThreadSafe setThreadSafe methods.
auto LLC = std::make_shared<LruClockCache<int,int>>(LLCsize,
[ & ](int key) {
  readmiss++;
  return backingStore[key];
},
[ & ](int key, int value) {
  writemiss++;
  backingStore[key] = value;
});

// this is the multi-level cache that adds an L1 and an L2 infront of the LLC.
size_t L1size=1024*32; // this needs to be (power of 2) sized cache because it is direct-mapped (with N-way tags) cache
size_t L2size=1024*512; // this can be any size, it is LRU cache
CacheThreader<LruClockCache,int,int> cache(LLC,L1size,L2size);
cache.set(500,10); // if it is in L1 then returns directly in 1-2 nanoseconds
                    // if it is not in L1 then goes L2 and returns within ~50 nanoseconds if its an L2 hit
                    // if it is not L2 hit then it goes LLC in a thread-safe way and gets data much slower like 500 nanoseconds or more due to std::lock_guard
 
cache.get(500); // same as set method but returns a value

// currently multithreading not supported due to lack of write-invalidation method but with a few changes it is ready to be used as a read-only cache
// when invalidation method is implemented, it will be multithreaded read-write cache. For now, it is single-thread read-write cache.

cache.flush(); // write latest bits of data to the LLC
LLC.flush(); // write latest bits of data to the backing store