Merge pull request #109 from graphql-java/improve_memory_usage_of_no_op_value_cache

Short circuit value cache look up to avoid object allocations

Author: bbakerman

src/main/java/org/dataloader/DataLoaderHelper.java

@@ -331,22 +331,33 @@ CompletableFuture<List<V>> invokeLoader(List<K> keys, List<Object> keyContexts,
         CompletableFuture<List<Try<V>>> cacheCallCF = getFromValueCache(keys);
         return cacheCallCF.thenCompose(cachedValues -> {
 
-            assertState(keys.size() == cachedValues.size(), () -> "The size of the cached values MUST be the same size as the key list");
-
             // the following is NOT a Map because keys in data loader can repeat (by design)
             // and hence "a","b","c","b" is a valid set of keys
             List<Try<V>> valuesInKeyOrder = new ArrayList<>();
             List<Integer> missedKeyIndexes = new ArrayList<>();
             List<K> missedKeys = new ArrayList<>();
             List<Object> missedKeyContexts = new ArrayList<>();
-            for (int i = 0; i < keys.size(); i++) {
-                Try<V> cacheGet = cachedValues.get(i);
-                valuesInKeyOrder.add(cacheGet);
-                if (cacheGet.isFailure()) {
+
+            // if they return a ValueCachingNotSupported exception then we insert this special marker value, and it
+            // means it's a total miss, we need to get all these keys via the batch loader
+            if (cachedValues == NOT_SUPPORTED_LIST) {
+                for (int i = 0; i < keys.size(); i++) {
+                    valuesInKeyOrder.add(ALWAYS_FAILED);
                     missedKeyIndexes.add(i);
                     missedKeys.add(keys.get(i));
                     missedKeyContexts.add(keyContexts.get(i));
                 }
+            } else {
+                assertState(keys.size() == cachedValues.size(), () -> "The size of the cached values MUST be the same size as the key list");
+                for (int i = 0; i < keys.size(); i++) {
+                    Try<V> cacheGet = cachedValues.get(i);
+                    valuesInKeyOrder.add(cacheGet);
+                    if (cacheGet.isFailure()) {
+                        missedKeyIndexes.add(i);
+                        missedKeys.add(keys.get(i));
+                        missedKeyContexts.add(keyContexts.get(i));
+                    }
+                }
             }
             if (missedKeys.isEmpty()) {
                 //
@@ -442,9 +453,16 @@ int dispatchDepth() {
         }
     }
 
+    private final List<Try<V>> NOT_SUPPORTED_LIST = emptyList();
+    private final CompletableFuture<List<Try<V>>> NOT_SUPPORTED = CompletableFuture.completedFuture(NOT_SUPPORTED_LIST);
+    private final Try<V> ALWAYS_FAILED = Try.alwaysFailed();
+
     private CompletableFuture<List<Try<V>>> getFromValueCache(List<K> keys) {
         try {
             return nonNull(valueCache.getValues(keys), () -> "Your ValueCache.getValues function MUST return a non null CompletableFuture");
+        } catch (ValueCache.ValueCachingNotSupported ignored) {
+            // use of a final field prevents CF object allocation for this special purpose
+            return NOT_SUPPORTED;
         } catch (RuntimeException e) {
             return CompletableFutureKit.failedFuture(e);
         }
@@ -456,16 +474,18 @@ private CompletableFuture<List<V>> setToValueCache(List<V> assembledValues, List
             if (completeValueAfterCacheSet) {
                 return nonNull(valueCache
                         .setValues(missedKeys, missedValues), () -> "Your ValueCache.setValues function MUST return a non null CompletableFuture")
-                        // we dont trust the set cache to give us the values back - we have them - lets use them
-                        // if the cache set fails - then they wont be in cache and maybe next time they will
+                        // we don't trust the set cache to give us the values back - we have them - lets use them
+                        // if the cache set fails - then they won't be in cache and maybe next time they will
                         .handle((ignored, setExIgnored) -> assembledValues);
             } else {
                 // no one is waiting for the set to happen here so if its truly async
-                // it will happen eventually but no result will be dependant on it
+                // it will happen eventually but no result will be dependent on it
                 valueCache.setValues(missedKeys, missedValues);
             }
+        } catch (ValueCache.ValueCachingNotSupported ignored) {
+            // ok no set caching is fine if they say so
         } catch (RuntimeException ignored) {
-            // if we cant set values back into the cache - so be it - this must be a faulty
+            // if we can't set values back into the cache - so be it - this must be a faulty
             // ValueCache implementation
         }
         return CompletableFuture.completedFuture(assembledValues);

src/main/java/org/dataloader/ValueCache.java

@@ -74,13 +74,18 @@ static <K, V> ValueCache<K, V> defaultValueCache() {
      * a successful Try contain the cached value is returned.
      * <p>
      * You MUST return a List that is the same size as the keys passed in.  The code will assert if you do not.
+     * <p>
+     * If your cache does not have anything in it at all, and you want to quickly short-circuit this method and avoid any object allocation
+     * then throw {@link ValueCachingNotSupported} and the code will know there is nothing in cache at this time.
      *
      * @param keys the list of keys to get cached values for.
      *
      * @return a future containing a list of {@link Try} cached values for each key passed in.
+     *
+     * @throws ValueCachingNotSupported if this cache wants to short-circuit this method completely
      */
-    default CompletableFuture<List<Try<V>>> getValues(List<K> keys) {
-        List<CompletableFuture<Try<V>>> cacheLookups = new ArrayList<>();
+    default CompletableFuture<List<Try<V>>> getValues(List<K> keys) throws ValueCachingNotSupported {
+        List<CompletableFuture<Try<V>>> cacheLookups = new ArrayList<>(keys.size());
         for (K key : keys) {
             CompletableFuture<Try<V>> cacheTry = Try.tryFuture(get(key));
             cacheLookups.add(cacheTry);
@@ -106,8 +111,10 @@ default CompletableFuture<List<Try<V>>> getValues(List<K> keys) {
      * @param values the values to store
      *
      * @return a future containing the stored values for fluent composition
+     *
+     * @throws ValueCachingNotSupported if this cache wants to short-circuit this method completely
      */
-    default CompletableFuture<List<V>> setValues(List<K> keys, List<V> values) {
+    default CompletableFuture<List<V>> setValues(List<K> keys, List<V> values) throws ValueCachingNotSupported {
         List<CompletableFuture<V>> cacheSets = new ArrayList<>();
         for (int i = 0; i < keys.size(); i++) {
             K k = keys.get(i);
@@ -140,4 +147,15 @@ default CompletableFuture<List<V>> setValues(List<K> keys, List<V> values) {
      * @return a void future for error handling and fluent composition
      */
     CompletableFuture<Void> clear();
+
+
+    /**
+     * This special exception can be used to short-circuit a caching method
+     */
+    class ValueCachingNotSupported extends UnsupportedOperationException {
+        @Override
+        public Throwable fillInStackTrace() {
+            return this;
+        }
+    }
 }

src/main/java/org/dataloader/impl/NoOpValueCache.java

@@ -1,9 +1,11 @@
 package org.dataloader.impl;
 
 
+import org.dataloader.Try;
 import org.dataloader.ValueCache;
 import org.dataloader.annotations.Internal;
 
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 /**
@@ -20,37 +22,55 @@
 @Internal
 public class NoOpValueCache<K, V> implements ValueCache<K, V> {
 
-    public static NoOpValueCache<?, ?> NOOP = new NoOpValueCache<>();
+    /**
+     * a no op value cache instance
+     */
+    public static final NoOpValueCache<?, ?> NOOP = new NoOpValueCache<>();
+
+    // avoid object allocation by using a final field
+    private final ValueCachingNotSupported NOT_SUPPORTED = new ValueCachingNotSupported();
+    private final CompletableFuture<V> NOT_SUPPORTED_CF = CompletableFutureKit.failedFuture(NOT_SUPPORTED);
+    private final CompletableFuture<Void> NOT_SUPPORTED_VOID_CF = CompletableFuture.completedFuture(null);
 
     /**
      * {@inheritDoc}
      */
     @Override
     public CompletableFuture<V> get(K key) {
-        return CompletableFutureKit.failedFuture(new UnsupportedOperationException());
+        return NOT_SUPPORTED_CF;
+    }
+
+    @Override
+    public CompletableFuture<List<Try<V>>> getValues(List<K> keys) throws ValueCachingNotSupported {
+        throw NOT_SUPPORTED;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public CompletableFuture<V> set(K key, V value) {
-        return CompletableFuture.completedFuture(value);
+        return NOT_SUPPORTED_CF;
+    }
+
+    @Override
+    public CompletableFuture<List<V>> setValues(List<K> keys, List<V> values) throws ValueCachingNotSupported {
+        throw NOT_SUPPORTED;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public CompletableFuture<Void> delete(K key) {
-        return CompletableFuture.completedFuture(null);
+        return NOT_SUPPORTED_VOID_CF;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public CompletableFuture<Void> clear() {
-        return CompletableFuture.completedFuture(null);
+        return NOT_SUPPORTED_VOID_CF;
     }
 }