LFU and LRU strategy

Author: sharvin2187

.gitignore

@@ -0,0 +1,29 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,33 @@
+import evictionpolicy.EvictionPolicy;
+import evictionpolicy.EvictionPolicyFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GenericCache<T> {
+    int capacity;
+    Map<String, T> store = new HashMap<>();
+    EvictionPolicy policy;
+
+    GenericCache(int capacity, EvictionPolicy policy) {
+        this.capacity = capacity;
+        this.policy = policy;
+    }
+
+    public T get(String key) throws KeyNotFoundException {
+        if (!store.containsKey(key)) {
+            throw new KeyNotFoundException();
+        }
+        policy.recordKeyAcccess(key);
+        return store.get(key);
+    }
+
+    public void put(String key, T value) {
+        if (!store.containsKey(key) && store.size() == capacity) {
+            String toEvict = policy.pollKeyToEvict();
+            store.remove(toEvict);
+        }
+        policy.recordKeyAcccess(key);
+        store.put(key, value);
+    }
+}

.idea/modules.xml

@@ -0,0 +1,2 @@
+public class KeyNotFoundException extends Exception {
+}

.idea/vcs.xml

@@ -0,0 +1,12 @@
+package LList;
+
+public class LLNode {
+    public String val;
+    public LLNode prev, next;
+
+    public LLNode(String val, LLNode prev, LLNode next) {
+        this.val = val;
+        this.next = next;
+        this.prev = prev;
+    }
+}

GenericCache.iml

@@ -0,0 +1,44 @@
+package LList;
+
+public class LList {
+    LLNode root = new LLNode("root", null, null);
+    LLNode curr = root;
+
+    // Adds a val to the end;
+    public LLNode add(String val) {
+        curr.next = new LLNode(val, curr, null);
+        curr = curr.next;
+        return curr;
+    }
+
+    public void remove(LLNode todel) {
+        assert todel != root;
+        LLNode before = todel.prev;
+        LLNode after = todel.next;
+        before.next = after;
+        if (after != null) {
+            after.prev = before;
+        }
+        if (curr == todel) {
+            curr = before;
+        }
+        todel.prev = null;
+        todel.next = null;
+    }
+
+    public LLNode pollFirst() {
+        assert curr != root;
+        LLNode temp = root.next;
+        remove(temp);
+        return temp;
+    }
+
+    public void debugLL() {
+        LLNode itr = root;
+        while (itr != null) {
+            System.out.print(itr.val + " => ");
+            itr = itr.next;
+        }
+        System.out.println("");
+    }
+}

src/GenericCache.java

@@ -0,0 +1,37 @@
+import evictionpolicy.EvictionPolicyFactory;
+
+public class Main {
+    static GenericCache cache;
+
+    public static void main(String[] args) {
+        cache = new GenericCache<Long>(3, EvictionPolicyFactory.getLFU());
+
+        attemptGet("k1");
+        recordAndSet("k1", 32L);
+        attemptGet("k1");
+        recordAndSet("k2", 33L);
+        recordAndSet("k2", 33L);
+        recordAndSet("k3", 34L);
+        recordAndSet("k1", 35L);
+        recordAndSet("k4", 33L);
+        recordAndSet("k5", 35L);
+        attemptGet("k4");
+        attemptGet("k1");
+        attemptGet("k2");
+    }
+
+    // prints key and value if key is found, otherwise prints "not found"
+    public static void attemptGet(String key) {
+        try {
+            Long val = (Long) cache.get(key);
+            System.out.println(key + " : " + val);
+        } catch (KeyNotFoundException k) {
+            System.out.println("not found: " + key);
+        }
+    }
+
+    public static void recordAndSet(String key, Long val) {
+        System.out.println("setting: " + key + " : " + val);
+        cache.put(key, val);
+    }
+}

src/KeyNotFoundException.java

@@ -0,0 +1,7 @@
+package evictionpolicy;
+
+public interface EvictionPolicy {
+    public void recordKeyAcccess(String key);
+
+    public String pollKeyToEvict();
+}

src/LList/LLNode.java

@@ -0,0 +1,11 @@
+package evictionpolicy;
+
+public class EvictionPolicyFactory {
+    public static EvictionPolicy getLRU() {
+        return new LRUEvictionPolicy();
+    }
+
+    public static EvictionPolicy getLFU() {
+        return new LFUEvictionPolicy();
+    }
+}

src/LList/LList.java

@@ -0,0 +1,53 @@
+package evictionpolicy;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import java.lang.Integer;
+import java.util.TreeSet;
+
+public class LFUEvictionPolicy implements EvictionPolicy {
+
+    private static class Pair implements Comparable<Pair> {
+        String key;
+        Integer count;
+
+        Pair(String key, Integer count) {
+            this.key = key;
+            this.count = count;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            if (count.compareTo(o.count) == 0) {
+                return key.compareTo(o.key);
+            }
+            return count.compareTo(o.count);
+        }
+    }
+
+    Map<String, Integer> keyToCount = new TreeMap<>();
+    TreeSet<Pair> keyAndCount = new TreeSet<>();
+
+    @Override
+    public void recordKeyAcccess(String key) {
+        Integer count = 0;
+        if (keyToCount.containsKey(key)) {
+            count = keyToCount.get(key);
+
+            keyToCount.remove(key);
+            keyAndCount.remove(new Pair(key, count));
+        }
+
+        keyToCount.put(key, count + 1);
+        keyAndCount.add(new Pair(key, count + 1));
+    }
+
+    @Override
+    public String pollKeyToEvict() {
+        Pair toEvict = keyAndCount.first();
+        keyToCount.remove(toEvict.key);
+        keyAndCount.remove(toEvict);
+        return toEvict.key;
+    }
+}

src/Main.java

@@ -0,0 +1,27 @@
+package evictionpolicy;
+
+import LList.LLNode;
+import LList.LList;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LRUEvictionPolicy implements EvictionPolicy {
+    Map<String, LLNode> keyToSequence = new HashMap<>();
+    LList sequence = new LList();
+
+    @Override
+    public void recordKeyAcccess(String key) {
+        if (keyToSequence.containsKey(key)) {
+            LLNode toRemove = keyToSequence.get(key);
+            keyToSequence.remove(key);
+            sequence.remove(toRemove);
+        }
+        keyToSequence.put(key, sequence.add(key));
+    }
+
+    @Override
+    public String pollKeyToEvict() {
+        return sequence.pollFirst().val;
+    }
+}