Remove LinkedDeque and replace with LinkedHashMap

After the recent changes the usage of the LinkedDeque fits quite well
with the insertion order semantics of LinkedHashMap, which also allows
for constant time additions and removals.

Signed-off-by: Andrew Ross <[email protected]>

server/src/main/java/org/opensearch/index/store/remote/utils/cache/LRUCache.java

@@ -17,6 +17,8 @@
 import org.opensearch.index.store.remote.utils.cache.stats.StatsCounter;
 
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.Objects;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiFunction;
@@ -45,15 +47,15 @@ class LRUCache<K, V> implements RefCountedCache<K, V> {
     private final HashMap<K, Node<K, V>> data;
 
     /** the LRU list */
-    private final LinkedDeque<Node<K, V>> lru;
+    private final LinkedHashMap<K, Node<K, V>> lru;
 
     private final RemovalListener<K, V> listener;
 
     private final Weigher<V> weigher;
 
     private final StatsCounter<K> statsCounter;
 
-    private volatile ReentrantLock lock;
+    private final ReentrantLock lock;
 
     /**
      * this tracks cache usage on the system (as long as cache entry is in the cache)
@@ -65,59 +67,33 @@ class LRUCache<K, V> implements RefCountedCache<K, V> {
      */
     private long activeUsage;
 
-    static class Node<K, V> implements Linked<Node<K, V>> {
+    static class Node<K, V> {
         final K key;
 
         V value;
 
         long weight;
 
-        Node<K, V> prev;
-
-        Node<K, V> next;
-
         int refCount;
 
         Node(K key, V value, long weight) {
             this.key = key;
             this.value = value;
             this.weight = weight;
-            this.prev = null;
-            this.next = null;
             this.refCount = 0;
         }
 
-        public Node<K, V> getPrevious() {
-            return prev;
-        }
-
-        public void setPrevious(Node<K, V> prev) {
-            this.prev = prev;
-        }
-
-        public Node<K, V> getNext() {
-            return next;
-        }
-
-        public void setNext(Node<K, V> next) {
-            this.next = next;
-        }
-
         public boolean evictable() {
             return (refCount == 0);
         }
-
-        V getValue() {
-            return value;
-        }
     }
 
     public LRUCache(long capacity, RemovalListener<K, V> listener, Weigher<V> weigher) {
         this.capacity = capacity;
         this.listener = listener;
         this.weigher = weigher;
         this.data = new HashMap<>();
-        this.lru = new LinkedDeque<>();
+        this.lru = new LinkedHashMap<>();
         this.lock = new ReentrantLock();
         this.statsCounter = new DefaultStatsCounter<>();
 
@@ -250,7 +226,7 @@ public void incRef(K key) {
 
                 if (node.evictable()) {
                     // since it become active, we should remove it from eviction list
-                    lru.remove(node);
+                    lru.remove(node.key);
                 }
 
                 node.refCount++;
@@ -273,7 +249,7 @@ public void decRef(K key) {
 
                 if (node.evictable()) {
                     // if it becomes evictable, we should add it to eviction list
-                    lru.add(node);
+                    lru.put(node.key, node);
                 }
 
                 if (node.refCount == 0) {
@@ -292,19 +268,15 @@ public long prune() {
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            Node<K, V> node = lru.peek();
-            // If weighted values are used, then the pending operations will adjust
-            // the size to reflect the correct weight
-            while (node != null) {
+            final Iterator<Node<K, V>> iterator = lru.values().iterator();
+            while (iterator.hasNext()) {
+                final Node<K, V> node = iterator.next();
+                iterator.remove();
                 data.remove(node.key, node);
                 sum += node.weight;
                 statsCounter.recordRemoval(node.weight);
                 listener.onRemoval(new RemovalNotification<>(node.key, node.value, RemovalReason.EXPLICIT));
-                Node<K, V> tmp = node;
-                node = node.getNext();
-                lru.remove(tmp);
             }
-
             usage -= sum;
         } finally {
             lock.unlock();
@@ -372,7 +344,7 @@ private void removeNode(K key) {
             }
             usage -= node.weight;
             if (node.evictable()) {
-                lru.remove(node);
+                lru.remove(node.key);
             }
             statsCounter.recordRemoval(node.weight);
             listener.onRemoval(new RemovalNotification<>(node.key, node.value, RemovalReason.EXPLICIT));
@@ -386,13 +358,10 @@ private boolean hasOverflowed() {
     private void evict() {
         // Attempts to evict entries from the cache if it exceeds the maximum
         // capacity.
-        while (hasOverflowed()) {
-            final Node<K, V> node = lru.poll();
-
-            if (node == null) {
-                return;
-            }
-
+        final Iterator<Node<K, V>> iterator = lru.values().iterator();
+        while (hasOverflowed() && iterator.hasNext()) {
+            final Node<K, V> node = iterator.next();
+            iterator.remove();
             // Notify the listener only if the entry was evicted
             data.remove(node.key, node);
             usage -= node.weight;