Introduce SoftValuedCache, which evicts more aggressively than SoftValuedHashMap.

20 files changed, 454 insertions, 71 deletions

diff --git a/src/main/java/com/amazon/carbonado/filter/Filter.java b/src/main/java/com/amazon/carbonado/filter/Filter.java
index 6f3cc55..f20e30a 100644
--- a/src/main/java/com/amazon/carbonado/filter/Filter.java
+++ b/src/main/java/com/amazon/carbonado/filter/Filter.java
@@ -25,7 +25,6 @@ import java.util.Collections;
 import java.util.List;

 import java.util.Map;

 

-import org.cojen.util.SoftValuedHashMap;

 import org.cojen.util.WeakCanonicalSet;

 import org.cojen.util.WeakIdentityMap;

 

@@ -36,6 +35,7 @@ import com.amazon.carbonado.info.ChainedProperty;
 import com.amazon.carbonado.info.StorableIntrospector;

 

 import com.amazon.carbonado.util.Appender;

+import com.amazon.carbonado.util.SoftValuedCache;

 

 /**

  * An immutable tree structure representing a query result filter. Filters can

@@ -88,7 +88,7 @@ public abstract class Filter<S extends Storable> implements Serializable, Append
      * @throws MalformedFilterException if filter expression is malformed

      */

     public static <S extends Storable> Filter<S> filterFor(Class<S> type, String expression) {

-        Map<Object, Filter<S>> filterCache = getFilterCache(type);

+        SoftValuedCache<Object, Filter<S>> filterCache = getFilterCache(type);

         synchronized (filterCache) {

             Filter<S> filter = filterCache.get(expression);

             if (filter == null) {

@@ -108,7 +108,7 @@ public abstract class Filter<S extends Storable> implements Serializable, Append
      * @see OpenFilter

      */

     public static <S extends Storable> OpenFilter<S> getOpenFilter(Class<S> type) {

-        Map<Object, Filter<S>> filterCache = getFilterCache(type);

+        SoftValuedCache<Object, Filter<S>> filterCache = getFilterCache(type);

         synchronized (filterCache) {

             Filter<S> filter = filterCache.get(OPEN_KEY);

             if (filter == null) {

@@ -128,7 +128,7 @@ public abstract class Filter<S extends Storable> implements Serializable, Append
      * @see ClosedFilter

      */

     public static <S extends Storable> ClosedFilter<S> getClosedFilter(Class<S> type) {

-        Map<Object, Filter<S>> filterCache = getFilterCache(type);

+        SoftValuedCache<Object, Filter<S>> filterCache = getFilterCache(type);

         synchronized (filterCache) {

             Filter<S> filter = filterCache.get(CLOSED_KEY);

             if (filter == null) {

@@ -140,11 +140,14 @@ public abstract class Filter<S extends Storable> implements Serializable, Append
     }

 

     @SuppressWarnings("unchecked")

-    private static <S extends Storable> Map<Object, Filter<S>> getFilterCache(Class<S> type) {

+    private static <S extends Storable> SoftValuedCache<Object, Filter<S>>

+        getFilterCache(Class<S> type)

+    {

         synchronized (cCache) {

-            Map<Object, Filter<S>> filterCache = (Map<Object, Filter<S>>) cCache.get(type);

+            SoftValuedCache<Object, Filter<S>> filterCache =

+                (SoftValuedCache<Object, Filter<S>>) cCache.get(type);

             if (filterCache == null) {

-                filterCache = new SoftValuedHashMap();

+                filterCache = SoftValuedCache.newCache(11);

                 cCache.put(type, filterCache);

             }

             return filterCache;

diff --git a/src/main/java/com/amazon/carbonado/gen/DelegateStorableGenerator.java b/src/main/java/com/amazon/carbonado/gen/DelegateStorableGenerator.java
index 67e93f8..84b8c83 100644
--- a/src/main/java/com/amazon/carbonado/gen/DelegateStorableGenerator.java
+++ b/src/main/java/com/amazon/carbonado/gen/DelegateStorableGenerator.java
@@ -29,11 +29,12 @@ import org.cojen.classfile.TypeDesc;
 

 import org.cojen.util.ClassInjector;

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 

 import com.amazon.carbonado.Storable;

 import com.amazon.carbonado.SupportException;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Generates and caches concrete implementations of {@link Storable} types

  * which delegate to {@link DelegateSupport}. The delegating classes extend

@@ -43,10 +44,10 @@ import com.amazon.carbonado.SupportException;
  * @since 1.2

  */

 public class DelegateStorableGenerator<S extends Storable> {

-    private static final Map<Object, Class> cCache;

+    private static final SoftValuedCache<Object, Class> cCache;

 

     static {

-        cCache = new SoftValuedHashMap();

+        cCache = SoftValuedCache.newCache(11);

     }

 

     /**

diff --git a/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java b/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java
index 1c63d0c..ef73a2c 100644
--- a/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java
+++ b/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java
@@ -38,7 +38,6 @@ import org.cojen.classfile.Opcode;
 import org.cojen.classfile.TypeDesc;

 import org.cojen.util.ClassInjector;

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 

 import com.amazon.carbonado.ConstraintException;

 import com.amazon.carbonado.IsolationLevel;

@@ -55,6 +54,8 @@ import com.amazon.carbonado.info.StorableProperty;
 

 import com.amazon.carbonado.sequence.SequenceValueProducer;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 import static com.amazon.carbonado.gen.CommonMethodNames.*;

 

 /**

@@ -88,7 +89,8 @@ public final class MasterStorableGenerator<S extends Storable> {
     private static final String DELETE_OP = "Delete";

 

     // Cache of generated abstract classes.

-    private static Map<Object, Class<? extends Storable>> cCache = new SoftValuedHashMap();

+    private static SoftValuedCache<Object, Class<? extends Storable>> cCache =

+        SoftValuedCache.newCache(11);

 

     /**

      * Returns an abstract implementation of the given Storable type, which

diff --git a/src/main/java/com/amazon/carbonado/gen/StorablePropertyMap.java b/src/main/java/com/amazon/carbonado/gen/StorablePropertyMap.java
index 6ad3466..0b8086b 100644
--- a/src/main/java/com/amazon/carbonado/gen/StorablePropertyMap.java
+++ b/src/main/java/com/amazon/carbonado/gen/StorablePropertyMap.java
@@ -29,20 +29,20 @@ import java.util.LinkedHashSet;
 import java.util.Map;

 import java.util.Set;

 

-import org.cojen.util.SoftValuedHashMap;

-

 import com.amazon.carbonado.Storable;

 import com.amazon.carbonado.info.StorableIntrospector;

 import com.amazon.carbonado.info.StorableProperty;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Basic implementation for {@link Storable#propertyMap} method.

  *

  * @author Brian S O'Neill

  */

 public class StorablePropertyMap<S extends Storable> extends AbstractMap<String, Object> {

-    private static final Map<Class, Set<String>> cPropertyNamesForType =

-        new SoftValuedHashMap();

+    private static final SoftValuedCache<Class, Set<String>> cPropertyNamesForType =

+        SoftValuedCache.newCache(11);

 

     public static <S extends Storable> StorablePropertyMap<S> createMap(Class<S> type, S storable)

     {

diff --git a/src/main/java/com/amazon/carbonado/layout/Layout.java b/src/main/java/com/amazon/carbonado/layout/Layout.java
index 98df22c..6c28740 100644
--- a/src/main/java/com/amazon/carbonado/layout/Layout.java
+++ b/src/main/java/com/amazon/carbonado/layout/Layout.java
@@ -35,8 +35,6 @@ import org.joda.time.DateTime;
 

 import org.apache.commons.logging.LogFactory;

 

-import org.cojen.util.SoftValuedHashMap;

-

 import com.amazon.carbonado.CorruptEncodingException;

 import com.amazon.carbonado.Cursor;

 import com.amazon.carbonado.FetchException;

@@ -53,6 +51,7 @@ import com.amazon.carbonado.synthetic.SyntheticKey;
 import com.amazon.carbonado.synthetic.SyntheticProperty;

 import com.amazon.carbonado.synthetic.SyntheticStorableBuilder;

 import com.amazon.carbonado.util.AnnotationDescPrinter;

+import com.amazon.carbonado.util.SoftValuedCache;

 

 import com.amazon.carbonado.capability.ResyncCapability;

 

@@ -63,10 +62,10 @@ import com.amazon.carbonado.capability.ResyncCapability;
  * @see LayoutFactory

  */

 public class Layout {

-    private static Map<Long, Class<? extends Storable>> cReconstructed;

+    private static SoftValuedCache<Long, Class<? extends Storable>> cReconstructed;

 

     static {

-        cReconstructed = Collections.synchronizedMap(new SoftValuedHashMap());

+        cReconstructed = SoftValuedCache.newCache(7);

     }

 

     static Class<? extends Storable> reconstruct(final Layout layout, ClassLoader loader)

diff --git a/src/main/java/com/amazon/carbonado/layout/LayoutFactory.java b/src/main/java/com/amazon/carbonado/layout/LayoutFactory.java
index 7b7953b..836ee54 100644
--- a/src/main/java/com/amazon/carbonado/layout/LayoutFactory.java
+++ b/src/main/java/com/amazon/carbonado/layout/LayoutFactory.java
@@ -29,8 +29,6 @@ import java.lang.reflect.Method;
 import java.util.Arrays;

 import java.util.Map;

 

-import org.cojen.util.SoftValuedHashMap;

-

 import com.amazon.carbonado.Cursor;

 import com.amazon.carbonado.FetchDeadlockException;

 import com.amazon.carbonado.FetchException;

@@ -55,6 +53,8 @@ import com.amazon.carbonado.info.StorableProperty;
 import com.amazon.carbonado.info.StorablePropertyAdapter;

 import com.amazon.carbonado.info.StorablePropertyAnnotation;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Factory for obtaining references to storable layouts.

  *

@@ -69,7 +69,7 @@ public class LayoutFactory implements LayoutCapability {
     final Storage<StoredLayout> mLayoutStorage;

     final Storage<StoredLayoutProperty> mPropertyStorage;

 

-    private Map<Class<? extends Storable>, Layout> mReconstructed;

+    private SoftValuedCache<Class<? extends Storable>, Layout> mReconstructed;

 

     /**

      * @throws com.amazon.carbonado.SupportException if underlying repository

@@ -339,7 +339,7 @@ public class LayoutFactory implements LayoutCapability {
         (Class<? extends Storable> reconstructed, Layout layout)

     {

         if (mReconstructed == null) {

-            mReconstructed = new SoftValuedHashMap();

+            mReconstructed = SoftValuedCache.newCache(7);

         }

         mReconstructed.put(reconstructed, layout);

     }

diff --git a/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java
index b370416..9a77f26 100644
--- a/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java
+++ b/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java
@@ -32,7 +32,6 @@ import org.cojen.classfile.Modifiers;
 import org.cojen.classfile.TypeDesc;

 

 import org.cojen.util.ClassInjector;

-import org.cojen.util.SoftValuedHashMap;

 

 import com.amazon.carbonado.Cursor;

 import com.amazon.carbonado.FetchException;

@@ -52,6 +51,7 @@ import com.amazon.carbonado.info.StorableIntrospector;
 import com.amazon.carbonado.info.StorableProperty;

 

 import com.amazon.carbonado.util.QuickConstructorGenerator;

+import com.amazon.carbonado.util.SoftValuedCache;

 

 import com.amazon.carbonado.gen.CodeBuilderUtil;

 

@@ -192,10 +192,10 @@ public class JoinedQueryExecutor<S extends Storable, T extends Storable>
     private static final String INNER_LOOP_FV_FIELD_NAME = "innerLoopFilterValues";

     private static final String ACTIVE_SOURCE_FIELD_NAME = "active";

 

-    private static final Map<StorableProperty, Class> cJoinerCursorClassCache;

+    private static final SoftValuedCache<StorableProperty, Class> cJoinerCursorClassCache;

 

     static {

-        cJoinerCursorClassCache = new SoftValuedHashMap();

+        cJoinerCursorClassCache = SoftValuedCache.newCache(11);

     }

 

     private static synchronized <S, T extends Storable> Joiner.Factory<S, T>

diff --git a/src/main/java/com/amazon/carbonado/qe/OrderingList.java b/src/main/java/com/amazon/carbonado/qe/OrderingList.java
index 7feed40..95d8328 100644
--- a/src/main/java/com/amazon/carbonado/qe/OrderingList.java
+++ b/src/main/java/com/amazon/carbonado/qe/OrderingList.java
@@ -31,14 +31,14 @@ import java.util.List;
 import java.util.Map;

 import java.util.Set;

 

-import org.cojen.util.SoftValuedHashMap;

-

 import com.amazon.carbonado.Storable;

 

 import com.amazon.carbonado.info.ChainedProperty;

 import com.amazon.carbonado.info.OrderedProperty;

 import com.amazon.carbonado.info.StorableIntrospector;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Produces unmodifiable lists of {@link OrderedProperty orderings}. Instances

  * are immutable, canonical and cached. Calls to "equals" and "hashCode" are

@@ -53,10 +53,10 @@ public class OrderingList<S extends Storable> extends AbstractList<OrderedProper
 

     private static final OrderingList EMPTY_LIST = new OrderingList();

 

-    private static final Map<Class, OrderingList> cCache;

+    private static final SoftValuedCache<Class, OrderingList> cCache;

 

     static {

-        cCache = new SoftValuedHashMap();

+        cCache = SoftValuedCache.newCache(11);

     }

 

     /**

diff --git a/src/main/java/com/amazon/carbonado/qe/PropertyFilterList.java b/src/main/java/com/amazon/carbonado/qe/PropertyFilterList.java
index 7d7966b..cedc05c 100644
--- a/src/main/java/com/amazon/carbonado/qe/PropertyFilterList.java
+++ b/src/main/java/com/amazon/carbonado/qe/PropertyFilterList.java
@@ -26,8 +26,6 @@ import java.util.HashMap;
 import java.util.List;

 import java.util.Map;

 

-import org.cojen.util.SoftValuedHashMap;

-

 import com.amazon.carbonado.Storable;

 

 import com.amazon.carbonado.filter.ExistsFilter;

@@ -37,6 +35,8 @@ import com.amazon.carbonado.filter.PropertyFilter;
 import com.amazon.carbonado.filter.RelOp;

 import com.amazon.carbonado.filter.Visitor;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Produces unmodifable lists of PropertyFilters which were originally all

  * 'and'ed together. The filters are ordered such that all '=' operators are

@@ -45,10 +45,10 @@ import com.amazon.carbonado.filter.Visitor;
  * @author Brian S O'Neill

  */

 class PropertyFilterList<S extends Storable> extends AbstractList<PropertyFilter<S>> {

-    private static Map<Filter<?>, PropertyFilterList> cCache;

+    private static SoftValuedCache<Filter<?>, PropertyFilterList> cCache;

 

     static {

-        cCache = new SoftValuedHashMap();

+        cCache = SoftValuedCache.newCache(11);

     }

 

     /**

diff --git a/src/main/java/com/amazon/carbonado/qe/QueryExecutorCache.java b/src/main/java/com/amazon/carbonado/qe/QueryExecutorCache.java
index 806365e..e114943 100644
--- a/src/main/java/com/amazon/carbonado/qe/QueryExecutorCache.java
+++ b/src/main/java/com/amazon/carbonado/qe/QueryExecutorCache.java
@@ -20,7 +20,6 @@ package com.amazon.carbonado.qe;
 

 import java.util.Map;

 

-import org.cojen.util.SoftValuedHashMap;

 import org.cojen.util.WeakIdentityMap;

 

 import com.amazon.carbonado.RepositoryException;

@@ -28,6 +27,8 @@ import com.amazon.carbonado.Storable;
 

 import com.amazon.carbonado.filter.Filter;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * QueryExecutors should be cached since expensive analysis is often required

  * to build them.

@@ -38,7 +39,7 @@ public class QueryExecutorCache<S extends Storable> implements QueryExecutorFact
     private final QueryExecutorFactory<S> mFactory;

 

     // Maps filters to maps which map ordering lists (possibly with hints) to executors.

-    private final Map<Filter<S>, Map<Object, QueryExecutor<S>>> mFilterToExecutor;

+    private final Map<Filter<S>, SoftValuedCache<Object, QueryExecutor<S>>> mFilterToExecutor;

 

     public QueryExecutorCache(QueryExecutorFactory<S> factory) {

         if (factory == null) {

@@ -62,12 +63,12 @@ public class QueryExecutorCache<S extends Storable> implements QueryExecutorFact
     public QueryExecutor<S> executor(Filter<S> filter, OrderingList<S> ordering, QueryHints hints)

         throws RepositoryException

     {

-        Map<Object, QueryExecutor<S>> map;

+        SoftValuedCache<Object, QueryExecutor<S>> cache;

         synchronized (mFilterToExecutor) {

-            map = mFilterToExecutor.get(filter);

-            if (map == null) {

-                map = new SoftValuedHashMap(7);

-                mFilterToExecutor.put(filter, map);

+            cache = mFilterToExecutor.get(filter);

+            if (cache == null) {

+                cache = SoftValuedCache.newCache(7);

+                mFilterToExecutor.put(filter, cache);

             }

         }

 

@@ -79,11 +80,11 @@ public class QueryExecutorCache<S extends Storable> implements QueryExecutorFact
         }

 

         QueryExecutor<S> executor;

-        synchronized (map) {

-            executor = map.get(key);

+        synchronized (cache) {

+            executor = cache.get(key);

             if (executor == null) {

                 executor = mFactory.executor(filter, ordering, hints);

-                map.put(key, executor);

+                cache.put(key, executor);

             }

         }

 

diff --git a/src/main/java/com/amazon/carbonado/qe/StandardQueryFactory.java b/src/main/java/com/amazon/carbonado/qe/StandardQueryFactory.java
index 4c80075..d6b99d6 100644
--- a/src/main/java/com/amazon/carbonado/qe/StandardQueryFactory.java
+++ b/src/main/java/com/amazon/carbonado/qe/StandardQueryFactory.java
@@ -31,6 +31,8 @@ import com.amazon.carbonado.Storable;
 import com.amazon.carbonado.filter.Filter;

 import com.amazon.carbonado.filter.FilterValues;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Builds and caches StandardQuery instances.

  *

@@ -40,7 +42,7 @@ public abstract class StandardQueryFactory<S extends Storable> implements QueryF
     private final Class<S> mType;

     private final boolean mLazySetExecutor;

 

-    private final Map<String, Query<S>> mStringToQuery;

+    private final SoftValuedCache<String, Query<S>> mStringToQuery;

 

     // Maps filters to maps which map ordering lists to queries.

     private final Map<Filter<S>, Map<OrderingList<S>, Query<S>>> mFilterToQuery;

@@ -59,7 +61,7 @@ public abstract class StandardQueryFactory<S extends Storable> implements QueryF
         }

         mType = type;

         mLazySetExecutor = lazySetExecutor;

-        mStringToQuery = new SoftValuedHashMap(7);

+        mStringToQuery = SoftValuedCache.newCache(7);

         mFilterToQuery = new WeakIdentityMap(7);

     }

 

diff --git a/src/main/java/com/amazon/carbonado/raw/GenericStorableCodec.java b/src/main/java/com/amazon/carbonado/raw/GenericStorableCodec.java
index ed2d09d..22f36ea 100644
--- a/src/main/java/com/amazon/carbonado/raw/GenericStorableCodec.java
+++ b/src/main/java/com/amazon/carbonado/raw/GenericStorableCodec.java
@@ -32,7 +32,6 @@ import org.cojen.classfile.TypeDesc;
 import org.cojen.util.ClassInjector;

 import org.cojen.util.IntHashMap;

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 import org.cojen.util.ThrowUnchecked;

 

 import com.amazon.carbonado.CorruptEncodingException;

@@ -55,6 +54,7 @@ import com.amazon.carbonado.gen.StorableGenerator;
 import com.amazon.carbonado.gen.TriggerSupport;

 

 import com.amazon.carbonado.util.QuickConstructorGenerator;

+import com.amazon.carbonado.util.SoftValuedCache;

 

 /**

  * Generic codec that supports any kind of storable by auto-generating and

@@ -67,7 +67,7 @@ public class GenericStorableCodec<S extends Storable> implements StorableCodec<S
     private static final String BLANK_KEY_FIELD_NAME = "blankKey$";

 

     // Maps GenericEncodingStrategy instances to Storable classes.

-    private static final Map cCache = new SoftValuedHashMap();

+    private static final SoftValuedCache cCache = SoftValuedCache.newCache(11);

 

     /**

      * Returns an instance of the codec. The Storable type itself may be an

@@ -291,10 +291,10 @@ public class GenericStorableCodec<S extends Storable> implements StorableCodec<S
     }

 

     // Maps codec key and OrderedProperty[] keys to SearchKeyFactory instances.

-    private static final Map cCodecSearchKeyFactories = new SoftValuedHashMap();

+    private static final SoftValuedCache cCodecSearchKeyFactories = SoftValuedCache.newCache(11);

 

     // Maps codec key and layout generations to Decoders.

-    private static final Map cCodecDecoders = new SoftValuedHashMap();

+    private static final SoftValuedCache cCodecDecoders = SoftValuedCache.newCache(11);

 

     private final Object mCodecKey;

     private final GenericStorableCodecFactory mFactory;

diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java
index e929e6b..e40ce04 100644
--- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java
+++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java
@@ -43,7 +43,6 @@ import org.cojen.classfile.Opcode;
 import org.cojen.classfile.TypeDesc;

 import org.cojen.util.ClassInjector;

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 

 import org.joda.time.ReadableInstant;

 

@@ -65,6 +64,8 @@ import com.amazon.carbonado.gen.StorableGenerator;
 import com.amazon.carbonado.gen.TriggerSupport;

 import static com.amazon.carbonado.gen.CommonMethodNames.*;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Generates concrete implementations of {@link Storable} types for

  * {@link JDBCRepository}.

@@ -87,10 +88,10 @@ class JDBCStorableGenerator<S extends Storable> {
     private static final int INITIAL_VERSION = 2;

     private static final int INCREMENT_VERSION = 3;

 

-    private static final Map<Object, Class<? extends Storable>> cCache;

+    private static final SoftValuedCache<Object, Class<? extends Storable>> cCache;

 

     static {

-        cCache = new SoftValuedHashMap();

+        cCache = SoftValuedCache.newCache(11);

     }

 

     static <S extends Storable> Class<? extends S> getGeneratedClass(JDBCStorableInfo<S> info,

diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableIntrospector.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableIntrospector.java
index 042974f..acba43e 100644
--- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableIntrospector.java
+++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableIntrospector.java
@@ -46,7 +46,6 @@ import org.apache.commons.logging.LogFactory;
 

 import org.cojen.classfile.TypeDesc;

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 import org.cojen.util.ThrowUnchecked;

 

 import com.amazon.carbonado.capability.IndexInfo;

@@ -66,6 +65,8 @@ import com.amazon.carbonado.info.StorableProperty;
 import com.amazon.carbonado.info.StorablePropertyAdapter;

 import com.amazon.carbonado.info.StorablePropertyConstraint;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Provides additional metadata for a {@link Storable} type needed by

  * JDBCRepository. The storable type must match to a table in an external

@@ -80,7 +81,8 @@ import com.amazon.carbonado.info.StorablePropertyConstraint;
 public class JDBCStorableIntrospector extends StorableIntrospector {

     // Maps compound keys to softly referenced JDBCStorableInfo objects.

     @SuppressWarnings("unchecked")

-    private static Map<Object, JDBCStorableInfo<?>> cCache = new SoftValuedHashMap();

+    private static SoftValuedCache<Object, JDBCStorableInfo<?>> cCache =

+        SoftValuedCache.newCache(11);

 

     /**

      * Examines the given class and returns a JDBCStorableInfo describing it. A

diff --git a/src/main/java/com/amazon/carbonado/repo/map/Key.java b/src/main/java/com/amazon/carbonado/repo/map/Key.java
index 9348516..86a0023 100644
--- a/src/main/java/com/amazon/carbonado/repo/map/Key.java
+++ b/src/main/java/com/amazon/carbonado/repo/map/Key.java
@@ -34,7 +34,6 @@ import org.cojen.classfile.Modifiers;
 import org.cojen.classfile.TypeDesc;

 

 import org.cojen.util.ClassInjector;

-import org.cojen.util.SoftValuedHashMap;

 

 import com.amazon.carbonado.Storable;

 

@@ -45,6 +44,8 @@ import com.amazon.carbonado.info.StorableProperty;
 

 import com.amazon.carbonado.gen.CodeBuilderUtil;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * 

  *

@@ -82,10 +83,10 @@ class Key<S extends Storable> implements Comparable<Key<S>> {
         void setKeyValues(S storable, Object[] identityValues, Object rangeValue);

     }

 

-    private static final Map<Class, Assigner> mAssigners;

+    private static final SoftValuedCache<Class, Assigner> mAssigners;

 

     static {

-        mAssigners = new SoftValuedHashMap();

+        mAssigners = SoftValuedCache.newCache(11);

     }

 

     public static synchronized <S extends Storable> Assigner<S> getAssigner(Class<S> clazz) {

diff --git a/src/main/java/com/amazon/carbonado/spi/LobEngine.java b/src/main/java/com/amazon/carbonado/spi/LobEngine.java
index 143bd26..0262890 100644
--- a/src/main/java/com/amazon/carbonado/spi/LobEngine.java
+++ b/src/main/java/com/amazon/carbonado/spi/LobEngine.java
@@ -30,7 +30,6 @@ import java.util.Map;
 import java.util.List;

 

 import org.cojen.util.KeyFactory;

-import org.cojen.util.SoftValuedHashMap;

 

 import com.amazon.carbonado.Cursor;

 import com.amazon.carbonado.FetchException;

@@ -58,6 +57,8 @@ import com.amazon.carbonado.lob.Lob;
 import com.amazon.carbonado.sequence.SequenceValueGenerator;

 import com.amazon.carbonado.sequence.SequenceValueProducer;

 

+import com.amazon.carbonado.util.SoftValuedCache;

+

 /**

  * Complete Lob support for repositories, although repository is responsible

  * for binding Lob properties to this engine. Lobs are referenced by locators,

@@ -88,7 +89,7 @@ public class LobEngine {
     final Storage<StoredLob.Block> mLobBlockStorage;

     final SequenceValueProducer mLocatorSequence;

 

-    private Map mTriggers;

+    private SoftValuedCache mTriggers;

 

     /**

      * @param lobRepo storage for Lobs - should not be replicated

@@ -460,7 +461,7 @@ public class LobEngine {
             }

 

             if (mTriggers == null) {

-                mTriggers = new SoftValuedHashMap();

+                mTriggers = SoftValuedCache.newCache(7);

             }

 

             mTriggers.put(key, trigger);

diff --git a/src/main/java/com/amazon/carbonado/util/BelatedCreator.java b/src/main/java/com/amazon/carbonado/util/BelatedCreator.java
index 513a0c0..cc476cf 100644
--- a/src/main/java/com/amazon/carbonado/util/BelatedCreator.java
+++ b/src/main/java/com/amazon/carbonado/util/BelatedCreator.java
@@ -36,7 +36,6 @@ import org.cojen.classfile.Modifiers;
 import org.cojen.classfile.TypeDesc;

 

 import org.cojen.util.ClassInjector;

-import org.cojen.util.SoftValuedHashMap;

 

 /**

  * Generic one-shot factory which supports late object creation. If the object

@@ -54,12 +53,12 @@ import org.cojen.util.SoftValuedHashMap;
 public abstract class BelatedCreator<T, E extends Exception> {

     private static final String REF_FIELD_NAME = "ref";

 

-    private static final Map<Class<?>, Class<?>> cWrapperCache;

+    private static final SoftValuedCache<Class<?>, Class<?>> cWrapperCache;

 

     private static final ExecutorService cThreadPool;

 

     static {

-        cWrapperCache = new SoftValuedHashMap();

+        cWrapperCache = SoftValuedCache.newCache(11);

         cThreadPool = Executors.newCachedThreadPool(new TFactory());

     }

 

diff --git a/src/main/java/com/amazon/carbonado/util/Converter.java b/src/main/java/com/amazon/carbonado/util/Converter.java
index 61f832a..44f28eb 100644
--- a/src/main/java/com/amazon/carbonado/util/Converter.java
+++ b/src/main/java/com/amazon/carbonado/util/Converter.java
@@ -38,7 +38,6 @@ import org.cojen.classfile.Opcode;
 import org.cojen.classfile.TypeDesc;

 

 import org.cojen.util.ClassInjector;

-import org.cojen.util.SoftValuedHashMap;

 

 /**

  * General purpose type converter. Custom conversions are possible by supplying

@@ -50,7 +49,8 @@ import org.cojen.util.SoftValuedHashMap;
  * @since 1.2

  */

 public abstract class Converter {

-    private static final Map<Class, Class<? extends Converter>> cCache = new SoftValuedHashMap();

+    private static final SoftValuedCache<Class, Class<? extends Converter>> cCache =

+        SoftValuedCache.newCache(7);

 

     /**

      * @param converterType type of converter to generate

diff --git a/src/main/java/com/amazon/carbonado/util/QuickConstructorGenerator.java b/src/main/java/com/amazon/carbonado/util/QuickConstructorGenerator.java
index 7a10440..a746c1f 100644
--- a/src/main/java/com/amazon/carbonado/util/QuickConstructorGenerator.java
+++ b/src/main/java/com/amazon/carbonado/util/QuickConstructorGenerator.java
@@ -29,7 +29,6 @@ import org.cojen.classfile.CodeBuilder;
 import org.cojen.classfile.TypeDesc;

 import org.cojen.util.ClassInjector;

 import org.cojen.util.WeakIdentityMap;

-import org.cojen.util.SoftValuedHashMap;

 

 /**

  * Generates code to invoke constructors. This is a replacement for {@link

@@ -48,7 +47,7 @@ import org.cojen.util.SoftValuedHashMap;
 public class QuickConstructorGenerator {

     // Map<factory class, Map<object type, factory instance>>

     @SuppressWarnings("unchecked")

-    private static Map<Class<?>, Map<Class<?>, Object>> cCache = new WeakIdentityMap();

+    private static Map<Class<?>, SoftValuedCache<Class<?>, Object>> cCache = new WeakIdentityMap();

 

     /**

      * Returns a factory instance for one type of object. Each method in the

@@ -87,9 +86,9 @@ public class QuickConstructorGenerator {
      */

     @SuppressWarnings("unchecked")

     public static synchronized <F> F getInstance(Class<?> objectType, Class<F> factory) {

-        Map<Class<?>, Object> innerCache = cCache.get(factory);

+        SoftValuedCache<Class<?>, Object> innerCache = cCache.get(factory);

         if (innerCache == null) {

-            innerCache = new SoftValuedHashMap();

+            innerCache = SoftValuedCache.newCache(7);

             cCache.put(factory, innerCache);

         }

         F instance = (F) innerCache.get(objectType);

diff --git a/src/main/java/com/amazon/carbonado/util/SoftValuedCache.java b/src/main/java/com/amazon/carbonado/util/SoftValuedCache.java
new file mode 100644
index 0000000..3e9e767
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/util/SoftValuedCache.java
@@ -0,0 +1,372 @@
+/*

+ * Copyright 2010 Amazon Technologies, Inc. or its affiliates.

+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks

+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.

+ *

+ * Licensed 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 com.amazon.carbonado.util;

+

+import java.lang.ref.Reference;

+import java.lang.ref.ReferenceQueue;

+import java.lang.ref.SoftReference;

+

+/**

+ * Simple thread-safe cache which evicts entries via a shared background

+ * thread. Cache permits null keys, but not null values.

+ *

+ * @author Brian S O'Neill

+ */

+public abstract class SoftValuedCache<K, V> {

+    // Design note: Public class is abstract to make it easy to swap out this

+    // implementation with something available in a shared collection library.

+

+    public static <K, V> SoftValuedCache<K, V> newCache(int capacity) {

+        return new Impl<K, V>(capacity);

+    }

+

+    public abstract int size();

+

+    public abstract boolean isEmpty();

+

+    public abstract V get(K key);

+

+    public abstract V put(K key, V value);

+

+    public abstract V putIfAbsent(K key, V value);

+

+    public abstract V remove(K key);

+

+    public abstract boolean remove(K key, V value);

+

+    public abstract boolean replace(K key, V oldValue, V newValue);

+

+    public abstract V replace(K key, V value);

+

+    public abstract void clear();

+

+    public abstract String toString();

+

+    private static class Impl<K, V> extends SoftValuedCache<K, V> {

+        private static final float LOAD_FACTOR = 0.75f;

+

+        private Entry<K, V>[] mEntries;

+        private int mSize;

+        private int mThreshold;

+

+        Impl(int capacity) {

+            mEntries = new Entry[capacity];

+            mThreshold = (int) (capacity * LOAD_FACTOR);

+        }

+

+        @Override

+        public synchronized int size() {

+            return mSize;

+        }

+

+        @Override

+        public synchronized boolean isEmpty() {

+            return mSize == 0;

+        }

+

+        @Override

+        public synchronized V get(K key) {

+            int hash = key == null ? 0 : key.hashCode();

+            Entry<K, V>[] entries = mEntries;

+            int index = (hash & 0x7fffffff) % entries.length;

+            for (Entry<K, V> e = entries[index]; e != null; e = e.mNext) {

+                if (e.matches(key, hash)) {

+                    return e.get();

+                }

+            }

+            return null;

+        }

+

+        @Override

+        public synchronized V put(K key, V value) {

+            int hash = key == null ? 0 : key.hashCode();

+            Entry<K, V>[] entries = mEntries;

+            int index = (hash & 0x7fffffff) % entries.length;

+            for (Entry<K, V> e = entries[index], prev = null; e != null; e = e.mNext) {

+                if (e.matches(key, hash)) {

+                    V old = e.get();

+                    e.clear();

+                    Entry<K, V> newEntry;

+                    if (prev == null) {

+                        newEntry = new Entry<K, V>(this, hash, key, value, e.mNext);

+                    } else {

+                        prev.mNext = e.mNext;

+                        newEntry = new Entry<K, V>(this, hash, key, value, entries[index]);

+                    }

+                    entries[index] = newEntry;

+                    return old;

+                } else {

+                    prev = e;

+                }

+            }

+

+            if (mSize >= mThreshold) {

+                cleanup();

+                if (mSize >= mThreshold) {

+                    rehash();

+                    entries = mEntries;

+                    index = (hash & 0x7fffffff) % entries.length;

+                }

+            }

+

+            entries[index] = new Entry<K, V>(this, hash, key, value, entries[index]);

+            mSize++;

+            return null;

+        }

+

+        @Override

+        public synchronized V putIfAbsent(K key, V value) {

+            V existing = get(key);

+            return existing == null ? put(key, value) : existing;

+        }

+

+        @Override

+        public synchronized V remove(K key) {

+            int hash = key == null ? 0 : key.hashCode();

+            Entry<K, V>[] entries = mEntries;

+            int index = (hash & 0x7fffffff) % entries.length;

+            for (Entry<K, V> e = entries[index], prev = null; e != null; e = e.mNext) {

+                if (e.matches(key, hash)) {

+                    V old = e.get();

+                    e.clear();

+                    if (prev == null) {

+                        entries[index] = e.mNext;

+                    } else {

+                        prev.mNext = e.mNext;

+                    }

+                    mSize--;

+                    return old;

+                } else {

+                    prev = e;

+                }

+            }

+            return null;

+        }

+

+        @Override

+        public synchronized boolean remove(K key, V value) {

+            V existing = get(key);

+            if (existing != null && existing.equals(value)) {

+                remove(key);

+                return true;

+            } else {

+                return false;

+            }

+        }

+

+        @Override

+        public synchronized boolean replace(K key, V oldValue, V newValue) {

+            V existing = get(key);

+            if (existing != null && existing.equals(oldValue)) {

+                put(key, newValue);

+                return true;

+            } else {

+                return false;

+            }

+        }

+

+        @Override

+        public synchronized V replace(K key, V value) {

+            return get(key) == null ? null : put(key, value);

+        }

+

+        @Override

+        public synchronized void clear() {

+            Entry[] entries = mEntries;

+            for (int i=entries.length; --i>=0; ) {

+                Entry e = entries[i];

+                if (e != null) {

+                    e.clear();

+                    entries[i] = null;

+                }

+            }

+            mSize = 0;

+        }

+

+        @Override

+        public synchronized String toString() {

+            if (isEmpty()) {

+                return "{}";

+            }

+

+            StringBuilder b = new StringBuilder();

+            b.append('{');

+

+            Entry<K, V>[] entries = mEntries;

+            int removed = 0;

+            boolean any = false;

+

+            for (int i=entries.length; --i>=0 ;) {

+                for (Entry<K, V> e = entries[i], prev = null; e != null; e = e.mNext) {

+                    V value = e.get();

+                    if (value == null) {

+                        // Clean up after a cleared Reference.

+                        if (prev == null) {

+                            entries[i] = e.mNext;

+                        } else {

+                            prev.mNext = e.mNext;

+                        }

+                        removed++;

+                    } else {

+                        prev = e;

+                        if (any) {

+                            b.append(',').append(' ');

+                        }

+                        K key = e.mKey;

+                        b.append(key).append('=').append(value);

+                        any = true;

+                    }

+                }

+            }

+

+            mSize -= removed;

+

+            b.append('}');

+            return b.toString();

+        }

+

+        synchronized void removeCleared(Entry<K, V> cleared) {

+            Entry<K, V>[] entries = mEntries;

+            int index = (cleared.mHash & 0x7fffffff) % entries.length;

+            for (Entry<K, V> e = entries[index], prev = null; e != null; e = e.mNext) {

+                if (e == cleared) {

+                    if (prev == null) {

+                        entries[index] = e.mNext;

+                    } else {

+                        prev.mNext = e.mNext;

+                    }

+                    mSize--;

+                    return;

+                } else {

+                    prev = e;

+                }

+            }

+        }

+

+        private synchronized void cleanup() {

+            Entry<K, V>[] entries = mEntries;

+            int removed = 0;

+

+            for (int i=entries.length; --i>=0 ;) {

+                for (Entry<K, V> e = entries[i], prev = null; e != null; e = e.mNext) {

+                    if (e.get() == null) {

+                        // Clean up after a cleared Reference.

+                        if (prev == null) {

+                            entries[i] = e.mNext;

+                        } else {

+                            prev.mNext = e.mNext;

+                        }

+                        removed++;

+                    } else {

+                        prev = e;

+                    }

+                }

+            }

+

+            mSize -= removed;

+        }

+

+        private synchronized void rehash() {

+            Entry<K, V>[] oldEntries = mEntries;

+            int newCapacity = oldEntries.length * 2 + 1;

+            Entry<K, V>[] newEntries = new Entry[newCapacity];

+            int removed = 0;

+

+            for (int i=oldEntries.length; --i>=0 ;) {

+                for (Entry<K, V> old = oldEntries[i]; old != null; ) {

+                    Entry<K, V> e = old;

+                    old = old.mNext;

+                    // Only copy entry if its value hasn't been cleared.

+                    if (e.get() == null) {

+                        removed++;

+                    } else {

+                        int index = (e.mHash & 0x7fffffff) % newCapacity;

+                        e.mNext = newEntries[index];

+                        newEntries[index] = e;

+                    }

+                }

+            }

+

+            mEntries = newEntries;

+            mSize -= removed;

+            mThreshold = (int) (newCapacity * LOAD_FACTOR);

+        }

+    }

+

+    private static class Entry<K, V> extends Ref<V> {

+        final Impl<K, V> mCache;

+        final int mHash;

+        final K mKey;

+        Entry mNext;

+

+        Entry(Impl<K, V> cache, int hash, K key, V value, Entry next) {

+            super(value);

+            mCache = cache;

+            mHash = hash;

+            mKey = key;

+            mNext = next;

+        }

+

+        @Override

+        void remove() {

+            mCache.removeCleared(this);

+        }

+

+        boolean matches(K key, int hash) {

+            return hash == mHash && (key == null ? mKey == null : key.equals(mKey));

+        }

+    }

+

+    final static Evictor cEvictor;

+

+    static {

+        Evictor evictor = new Evictor();

+        evictor.setName("SoftValuedCache Evictor");

+        evictor.setDaemon(true);

+        evictor.setPriority(Thread.MAX_PRIORITY);

+        evictor.start();

+        cEvictor = evictor;

+    }

+

+    private static abstract class Ref<T> extends SoftReference<T> {

+        Ref(T referent) {

+            super(referent, cEvictor.mQueue);

+        }

+

+        abstract void remove();

+    }

+

+    private static class Evictor extends Thread {

+        final ReferenceQueue<Object> mQueue;

+

+        Evictor() {

+            mQueue = new ReferenceQueue<Object>();

+        }

+

+        @Override

+        public void run() {

+            try {

+                while (true) {

+                    ((Ref) mQueue.remove()).remove();

+                }

+            } catch (InterruptedException e) {

+            }

+        }

+    }

+}