commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t.@apache.org
Subject svn commit: r1776744 - /commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
Date Sat, 31 Dec 2016 13:47:19 GMT
Author: tv
Date: Sat Dec 31 13:47:19 2016
New Revision: 1776744

URL: http://svn.apache.org/viewvc?rev=1776744&view=rev
Log:
Performance improvements

Modified:
    commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java

Modified: commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java?rev=1776744&r1=1776743&r2=1776744&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
(original)
+++ commons/proper/jcs/trunk/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
Sat Dec 31 13:47:19 2016
@@ -64,21 +64,19 @@ public abstract class AbstractLRUMap<K,
     private final DoubleLinkedList<LRUElementDescriptor<K, V>> list;
 
     /** Map where items are stored by key. */
-    private Map<K, LRUElementDescriptor<K, V>> map;
+    private final Map<K, LRUElementDescriptor<K, V>> map;
 
-    /** stats */
-    int hitCnt = 0;
+    /** lock to keep map and list synchronous */
+    private final Lock lock = new ReentrantLock();
 
     /** stats */
-    int missCnt = 0;
+    private long hitCnt = 0;
 
     /** stats */
-    int putCnt = 0;
+    private long missCnt = 0;
 
-    /** make configurable */
-    private int chunkSize = 1;
-
-    private final Lock lock = new ReentrantLock();
+    /** stats */
+    private long putCnt = 0;
 
     /**
      * This creates an unbounded version. Setting the max objects will result in spooling
on
@@ -196,7 +194,7 @@ public abstract class AbstractLRUMap<K,
     @Override
     public V get( Object key )
     {
-        V retVal = null;
+        V retVal;
 
         if ( log.isDebugEnabled() )
         {
@@ -205,22 +203,28 @@ public abstract class AbstractLRUMap<K,
 
         LRUElementDescriptor<K, V> me = map.get( key );
 
-        if ( me != null )
+        if ( me == null )
+        {
+            missCnt++;
+            retVal = null;
+        }
+        else
         {
             hitCnt++;
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( "LRUMap hit for " + key );
-            }
-
             retVal = me.getPayload();
-
             list.makeFirst( me );
         }
-        else
+
+        if ( log.isDebugEnabled() )
         {
-            missCnt++;
-            log.debug( "LRUMap miss for " + key );
+            if ( me == null )
+            {
+                log.debug( "LRUMap miss for " + key );
+            }
+            else
+            {
+                log.debug( "LRUMap hit for " + key );
+            }
         }
 
         // verifyCache();
@@ -238,20 +242,23 @@ public abstract class AbstractLRUMap<K,
     public V getQuiet( Object key )
     {
         V ce = null;
-
         LRUElementDescriptor<K, V> me = map.get( key );
+
         if ( me != null )
         {
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( "LRUMap quiet hit for " + key );
-            }
-
             ce = me.getPayload();
         }
-        else if ( log.isDebugEnabled() )
+
+        if ( log.isDebugEnabled() )
         {
-            log.debug( "LRUMap quiet miss for " + key );
+            if ( me == null )
+            {
+                log.debug( "LRUMap quiet miss for " + key );
+            }
+            else
+            {
+                log.debug( "LRUMap quiet hit for " + key );
+            }
         }
 
         return ce;
@@ -300,17 +307,16 @@ public abstract class AbstractLRUMap<K,
         putCnt++;
 
         LRUElementDescriptor<K, V> old = null;
+        LRUElementDescriptor<K, V> me = new LRUElementDescriptor<K, V>(key, value);
+
         lock.lock();
         try
         {
-            // TODO address double synchronization of addFirst, use write lock
-            addFirst( key, value );
-            // this must be synchronized
-            LRUElementDescriptor<K, V> first = list.getFirst();
-            old = map.put(first.getKey(), first);
+            list.addFirst( me );
+            old = map.put(key, me);
 
             // If the node was the same as an existing node, remove it.
-            if ( old != null && first.getKey().equals(old.getKey()))
+            if ( old != null && key.equals(old.getKey()))
             {
                 list.remove( old );
             }
@@ -321,7 +327,6 @@ public abstract class AbstractLRUMap<K,
         }
 
         // If the element limit is reached, we need to spool
-
         if (shouldRemove())
         {
             if (log.isDebugEnabled())
@@ -332,7 +337,6 @@ public abstract class AbstractLRUMap<K,
             // The spool will put them in a disk event queue, so there is no
             // need to pre-queue the queuing. This would be a bit wasteful
             // and wouldn't save much time in this synchronous call.
-
             while ( shouldRemove() )
             {
                 lock.lock();
@@ -366,10 +370,10 @@ public abstract class AbstractLRUMap<K,
             {
                 log.debug( "update: After spool map size: " + map.size() );
             }
-            if ( map.size() != dumpCacheSize() )
+            if ( map.size() != list.size() )
             {
-                log.error("update: After spool, size mismatch: map.size() = " + map.size()
+ ", linked list size = "
-                        + dumpCacheSize());
+                log.error("update: After spool, size mismatch: map.size() = " + map.size()
+
+                        ", linked list size = " + list.size());
             }
         }
 
@@ -382,37 +386,6 @@ public abstract class AbstractLRUMap<K,
 
     protected abstract boolean shouldRemove();
 
-
-    /**
-     * Adds a new node to the start of the link list.
-     * <p>
-     * @param key
-     * @param val The feature to be added to the First
-     */
-    private void addFirst(K key, V val)
-    {
-        lock.lock();
-        try
-        {
-            LRUElementDescriptor<K, V> me = new LRUElementDescriptor<K, V>(key,
val);
-            list.addFirst( me );
-        }
-        finally
-        {
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Returns the size of the list.
-     * <p>
-     * @return int
-     */
-    private int dumpCacheSize()
-    {
-        return list.size();
-    }
-
     /**
      * Dump the cache entries from first to list for debugging.
      */
@@ -458,8 +431,8 @@ public abstract class AbstractLRUMap<K,
         }
 
         boolean found = false;
-        log.debug( "verifycache: mapContains " + map.size() + " elements, linked list contains
" + dumpCacheSize()
-            + " elements" );
+        log.debug( "verifycache: mapContains " + map.size() +
+                " elements, linked list contains " + list.size() + " elements" );
         log.debug( "verifycache: checking linked list by key " );
         for (LRUElementDescriptor<K, V> li = list.getFirst(); li != null; li = (LRUElementDescriptor<K,
V>) li.next )
         {
@@ -537,37 +510,6 @@ public abstract class AbstractLRUMap<K,
     }
 
     /**
-     * Logs an error is an element that should be in the cache is not.
-     * <p>
-     * @param key
-     */
-    @SuppressWarnings("unchecked") // No generics for public fields
-    protected void verifyCache( Object key )
-    {
-        if ( !log.isDebugEnabled() )
-        {
-            return;
-        }
-
-        boolean found = false;
-
-        // go through the linked list looking for the key
-        for (LRUElementDescriptor<K, V> li = list.getFirst(); li != null; li = (LRUElementDescriptor<K,
V>) li.next )
-        {
-            if ( li.getKey() == key )
-            {
-                found = true;
-                log.debug( "verifycache(key) key match: " + key );
-                break;
-            }
-        }
-        if ( !found )
-        {
-            log.error( "verifycache(key), couldn't find key! : " + key );
-        }
-    }
-
-    /**
      * This is called when an item is removed from the LRU. We just log some information.
      * <p>
      * Children can implement this method for special behavior.
@@ -584,24 +526,6 @@ public abstract class AbstractLRUMap<K,
     }
 
     /**
-     * The chunk size is the number of items to remove when the max is reached. By default
it is 1.
-     * <p>
-     * @param chunkSize The chunkSize to set.
-     */
-    public void setChunkSize( int chunkSize )
-    {
-        this.chunkSize = chunkSize;
-    }
-
-    /**
-     * @return Returns the chunkSize.
-     */
-    public int getChunkSize()
-    {
-        return chunkSize;
-    }
-
-    /**
      * @return IStats
      */
     public IStats getStatistics()
@@ -613,9 +537,9 @@ public abstract class AbstractLRUMap<K,
 
         elems.add(new StatElement<Integer>( "List Size", Integer.valueOf(list.size())
) );
         elems.add(new StatElement<Integer>( "Map Size", Integer.valueOf(map.size())
) );
-        elems.add(new StatElement<Integer>( "Put Count", Integer.valueOf(putCnt) )
);
-        elems.add(new StatElement<Integer>( "Hit Count", Integer.valueOf(hitCnt) )
);
-        elems.add(new StatElement<Integer>( "Miss Count", Integer.valueOf(missCnt)
) );
+        elems.add(new StatElement<Long>( "Put Count", Long.valueOf(putCnt) ) );
+        elems.add(new StatElement<Long>( "Hit Count", Long.valueOf(hitCnt) ) );
+        elems.add(new StatElement<Long>( "Miss Count", Long.valueOf(missCnt) ) );
 
         stats.setStatElements( elems );
 



Mime
View raw message