Update LFUCache.cpp

Author: zennyMe17

src/LFUCache.cpp

@@ -1,57 +1,73 @@
-#include "LRUCache.h"
-#include <algorithm> // Required for std::find
+#include "LFUCache.h"
+#include <iostream>
 
-LRUCache::LRUCache(int capacity) : capacity(capacity) {}
+LFUCache::LFUCache(size_t capacity) : capacity(capacity), hits(0), accesses(0) {}
 
-// Private helper to move a key to the front of the access_order list
-void LRUCache::moveToFront(int key) {
-    access_order.remove(key);
-    access_order.push_front(key);
+// --- New Methods ---
+double LFUCache::getHitRate() const {
+    if (accesses == 0) return 0.0;
+    return static_cast<double>(hits.load()) / accesses.load();
 }
 
-// Private helper to evict the least recently used item
-void LRUCache::evict() {
-    if (access_order.empty()) return;
-    
-    // Get the least recently used key from the back of the list
-    int key_to_evict = access_order.back();
-    access_order.pop_back();
-    
-    // Erase it from the cache map
-    cache.erase(key_to_evict);
+void LFUCache::resetStats() {
+    hits = 0;
+    accesses = 0;
 }
+// ---
 
-int LRUCache::get(int key) {
+int LFUCache::get(int key) {
     std::lock_guard<std::mutex> lock(cache_mutex);
+    accesses++; // Track every access
 
-    // If key is not in the cache, return -1
     if (cache.find(key) == cache.end()) {
-        return -1;
+        return -1; // Miss
     }
-
-    // Key exists, so it's being used. Move it to the front.
-    moveToFront(key);
 
-    // Note: Assuming the value is stored in the 'first' element of the pair
+    hits++; // Track hit
+    touch(key);
     return cache[key].first;
 }
 
-void LRUCache::put(int key, int value) {
+void LFUCache::put(int key, int value) {
     std::lock_guard<std::mutex> lock(cache_mutex);
-    
     if (capacity == 0) return;
 
-    // If key already exists, update its value and move it to the front
     if (cache.find(key) != cache.end()) {
         cache[key].first = value;
-        moveToFront(key);
+        touch(key);
     } else {
-        // If the cache is full, evict the least recently used item first
         if (cache.size() >= capacity) {
             evict();
         }
-        // Add the new key-value pair
-        cache[key] = {value, 0}; // Storing value in .first, .second is unused per your header
-        access_order.push_front(key);
+        cache[key] = {value, 1};
+        freq_map[1].push_front(key);
+    }
+}
+
+// Unchanged private helpers...
+void LFUCache::touch(int key) {
+    int old_freq = cache[key].second;
+    cache[key].second++;
+    freq_map[old_freq].remove(key);
+    if (freq_map[old_freq].empty()) {
+        freq_map.erase(old_freq);
+    }
+    freq_map[cache[key].second].push_front(key);
+}
+
+void LFUCache::evict() {
+    int min_freq = -1;
+    for(auto const& [freq, keys] : freq_map) {
+        if(min_freq == -1 || freq < min_freq) {
+            min_freq = freq;
+        }
+    }
+    if(min_freq != -1) {
+        int key_to_evict = freq_map[min_freq].back();
+        freq_map[min_freq].pop_back();
+        if (freq_map[min_freq].empty()) {
+            freq_map.erase(min_freq);
+        }
+        cache.erase(key_to_evict);
     }
 }