Fix for https://issues.apache.org/jira/browse/AMQ-3638

git-svn-id: https://svn.apache.org/repos/asf/activemq/trunk@1215432 13f79535-47bb-0310-9956-ffa450edef68

kahadb/src/main/java/org/apache/kahadb/util/LFUCache.java

@@ -0,0 +1,236 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kahadb.util;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * LFU cache implementation based on http://dhruvbird.com/lfu.pdf, with some notable differences:
+ * <ul>
+ * <li>
+ * Frequency list is stored as an array with no next/prev pointers between nodes: looping over the array should be faster and more CPU-cache friendly than
+ * using an ad-hoc linked-pointers structure.
+ * </li>
+ * <li>
+ * The max frequency is capped at the cache size to avoid creating more and more frequency list entries, and all elements residing in the max frequency entry
+ * are re-positioned in the frequency entry linked set in order to put most recently accessed elements ahead of less recently ones,
+ * which will be collected sooner.
+ * </li>
+ * <li>
+ * The eviction factor determines how many elements (more specifically, the percentage of) will be evicted.
+ * </li>
+ * </ul>
+ * As a consequence, this cache runs in *amortized* O(1) time (considering the worst case of having the lowest frequency at 0 and having to evict all
+ * elements).
+ *
+ * @author Sergio Bossa
+ */
+public class LFUCache<Key, Value> implements Map<Key, Value> {
+
+    private final Map<Key, CacheNode<Key, Value>> cache;
+    private final LinkedHashSet[] frequencyList;
+    private int lowestFrequency;
+    private int maxFrequency;
+    //
+    private final int maxCacheSize;
+    private final float evictionFactor;
+
+    public LFUCache(int maxCacheSize, float evictionFactor) {
+        if (evictionFactor <= 0 || evictionFactor >= 1) {
+            throw new IllegalArgumentException("Eviction factor must be greater than 0 and lesser than or equal to 1");
+        }
+        this.cache = new HashMap<Key, CacheNode<Key, Value>>(maxCacheSize);
+        this.frequencyList = new LinkedHashSet[maxCacheSize];
+        this.lowestFrequency = 0;
+        this.maxFrequency = maxCacheSize - 1;
+        this.maxCacheSize = maxCacheSize;
+        this.evictionFactor = evictionFactor;
+        initFrequencyList();
+    }
+
+    public Value put(Key k, Value v) {
+        Value oldValue = null;
+        CacheNode<Key, Value> currentNode = cache.get(k);
+        if (currentNode == null) {
+            if (cache.size() == maxCacheSize) {
+                doEviction();
+            }
+            LinkedHashSet<CacheNode<Key, Value>> nodes = frequencyList[0];
+            currentNode = new CacheNode(k, v, 0);
+            nodes.add(currentNode);
+            cache.put(k, currentNode);
+            lowestFrequency = 0;
+        } else {
+            oldValue = currentNode.v;
+            currentNode.v = v;
+        }
+        return oldValue;
+    }
+
+
+    public void putAll(Map<? extends Key, ? extends Value> map) {
+        for (Map.Entry<? extends Key, ? extends Value> me : map.entrySet()) {
+            put(me.getKey(), me.getValue());
+        }
+    }
+
+    public Value get(Object k) {
+        CacheNode<Key, Value> currentNode = cache.get(k);
+        if (currentNode != null) {
+            int currentFrequency = currentNode.frequency;
+            if (currentFrequency < maxFrequency) {
+                int nextFrequency = currentFrequency + 1;
+                LinkedHashSet<CacheNode<Key, Value>> currentNodes = frequencyList[currentFrequency];
+                LinkedHashSet<CacheNode<Key, Value>> newNodes = frequencyList[nextFrequency];
+                moveToNextFrequency(currentNode, nextFrequency, currentNodes, newNodes);
+                cache.put((Key) k, currentNode);
+                if (lowestFrequency == currentFrequency && currentNodes.isEmpty()) {
+                    lowestFrequency = nextFrequency;
+                }
+            } else {
+                // Hybrid with LRU: put most recently accessed ahead of others:
+                LinkedHashSet<CacheNode<Key, Value>> nodes = frequencyList[currentFrequency];
+                nodes.remove(currentNode);
+                nodes.add(currentNode);
+            }
+            return currentNode.v;
+        } else {
+            return null;
+        }
+    }
+
+    public Value remove(Object k) {
+        CacheNode<Key, Value> currentNode = cache.remove(k);
+        if (currentNode != null) {
+            LinkedHashSet<CacheNode<Key, Value>> nodes = frequencyList[currentNode.frequency];
+            nodes.remove(currentNode);
+            if (lowestFrequency == currentNode.frequency) {
+                findNextLowestFrequency();
+            }
+            return currentNode.v;
+        } else {
+            return null;
+        }
+    }
+
+    public int frequencyOf(Key k) {
+        CacheNode<Key, Value> node = cache.get(k);
+        if (node != null) {
+            return node.frequency + 1;
+        } else {
+            return 0;
+        }
+    }
+
+    public void clear() {
+        for (int i = 0; i <= maxFrequency; i++) {
+            frequencyList[i].clear();
+        }
+        cache.clear();
+        lowestFrequency = 0;
+    }
+
+    public Set<Key> keySet() {
+        return this.cache.keySet();
+    }
+
+    public Collection<Value> values() {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public Set<Entry<Key, Value>> entrySet() {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public int size() {
+        return cache.size();
+    }
+
+    public boolean isEmpty() {
+        return this.cache.isEmpty();
+    }
+
+    public boolean containsKey(Object o) {
+        return this.cache.containsKey(o);
+    }
+
+    public boolean containsValue(Object o) {
+        return false;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+
+    private void initFrequencyList() {
+        for (int i = 0; i <= maxFrequency; i++) {
+            frequencyList[i] = new LinkedHashSet<CacheNode<Key, Value>>();
+        }
+    }
+
+    private void doEviction() {
+        int currentlyDeleted = 0;
+        float target = maxCacheSize * evictionFactor;
+        while (currentlyDeleted < target) {
+            LinkedHashSet<CacheNode<Key, Value>> nodes = frequencyList[lowestFrequency];
+            if (nodes.isEmpty()) {
+                throw new IllegalStateException("Lowest frequency constraint violated!");
+            } else {
+                Iterator<CacheNode<Key, Value>> it = nodes.iterator();
+                while (it.hasNext() && currentlyDeleted++ < target) {
+                    CacheNode<Key, Value> node = it.next();
+                    it.remove();
+                    cache.remove(node.k);
+                }
+                if (!it.hasNext()) {
+                    findNextLowestFrequency();
+                }
+            }
+        }
+    }
+
+    private void moveToNextFrequency(CacheNode<Key, Value> currentNode, int nextFrequency, LinkedHashSet<CacheNode<Key, Value>> currentNodes, LinkedHashSet<CacheNode<Key, Value>> newNodes) {
+        currentNodes.remove(currentNode);
+        newNodes.add(currentNode);
+        currentNode.frequency = nextFrequency;
+    }
+
+    private void findNextLowestFrequency() {
+        while (lowestFrequency <= maxFrequency && frequencyList[lowestFrequency].isEmpty()) {
+            lowestFrequency++;
+        }
+        if (lowestFrequency > maxFrequency) {
+            lowestFrequency = 0;
+        }
+    }
+
+    private static class CacheNode<Key, Value> {
+
+        public final Key k;
+        public Value v;
+        public int frequency;
+
+        public CacheNode(Key k, Value v, int frequency) {
+            this.k = k;
+            this.v = v;
+            this.frequency = frequency;
+        }
+
+    }
+}