Apache Solr open-source search software
SOLR-15555 Improved caching on FilterQuery (#230)
Mike Drobf68bfad4c45d
diff --git a/solr/CHANGES.txt b/solr/CHANGES.txtindex b3aae42c081..410041babd4 100644--- a/solr/CHANGES.txt+++ b/solr/CHANGES.txt@@ -143,6 +143,10 @@ when told to. The admin UI now tells it to. (Nazerke Seidan, David Smiley)This was already working for XML & "javabin"/SolrJ. Previously, omitting the ID would be confusedfor a partial/atomic update. (David Smiley)+* SOLR-15555: Identical filter queries will no longer race to record a filterCache entry. Allows for async cache computation instead of+ all queries contending for the same set of locks on the cache. Fixed a bug with ramBytes usage reporting on filterCache.+ Upgraded Caffeine Cache to 2.9.2 (Mike Drob)+Other Changes----------------------* SOLR-15603: Add an option to activate Gradle build cache, build task cleanups (Alexis Tual, Dawid Weiss)diff --git a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.javaindex 3c6859c88d3..c400d6615b0 100644--- a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java+++ b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java@@ -58,6 +58,7 @@ import org.apache.solr.search.DocSetProducer;import org.apache.solr.search.DocSetUtil;import org.apache.solr.search.ExtendedQueryBase;import org.apache.solr.search.SolrIndexSearcher;+import org.apache.solr.util.TestInjection;/** @lucene.experimental */public final class SolrRangeQuery extends ExtendedQueryBase implements DocSetProducer {@@ -167,6 +168,7 @@ public final class SolrRangeQuery extends ExtendedQueryBase implements DocSetPro}private DocSet createDocSet(SolrIndexSearcher searcher, long cost) throws IOException {+ assert TestInjection.injectDocSetDelay();int maxDoc = searcher.maxDoc();BitDocSet liveDocs = searcher.getLiveDocSet();FixedBitSet liveBits = liveDocs.size() == maxDoc ? null : liveDocs.getBits();@@ -408,20 +410,21 @@ public final class SolrRangeQuery extends ExtendedQueryBase implements DocSetPro// first time, check our filter cacheboolean doCheck = !checkedFilterCache && context.ord == 0;checkedFilterCache = true;- SolrIndexSearcher solrSearcher = null;+ final SolrIndexSearcher solrSearcher;if (doCheck && searcher instanceof SolrIndexSearcher) {- solrSearcher = (SolrIndexSearcher)searcher;+ solrSearcher = (SolrIndexSearcher) searcher;if (solrSearcher.getFilterCache() == null) {doCheck = false;} else {- solrSearcher = (SolrIndexSearcher)searcher;answer = solrSearcher.getFilterCache().get(SolrRangeQuery.this);}} else {doCheck = false;+ solrSearcher = null;}if (answer != null) {+ // I'm not sure this ever happensreturn segStates[context.ord] = new SegState(new SegmentDocIdSet(answer, context));}@@ -452,6 +455,7 @@ public final class SolrRangeQuery extends ExtendedQueryBase implements DocSetProif (doCheck) {answer = createDocSet(solrSearcher, count);+ // This can be a naked put because the cache usually gets checked in SolrIndexSearchersolrSearcher.getFilterCache().put(SolrRangeQuery.this, answer);return segStates[context.ord] = new SegState(new SegmentDocIdSet(answer, context));}diff --git a/solr/core/src/java/org/apache/solr/response/transform/ChildDocTransformerFactory.java b/solr/core/src/java/org/apache/solr/response/transform/ChildDocTransformerFactory.javaindex 7983fd31c59..95902e276e7 100644--- a/solr/core/src/java/org/apache/solr/response/transform/ChildDocTransformerFactory.java+++ b/solr/core/src/java/org/apache/solr/response/transform/ChildDocTransformerFactory.java@@ -17,6 +17,7 @@package org.apache.solr.response.transform;import java.io.IOException;+import java.io.UncheckedIOException;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;@@ -179,7 +180,11 @@ public class ChildDocTransformerFactory extends TransformerFactory {SolrCache<Query, BitSetProducer> parentCache = request.getSearcher().getCache(CACHE_NAME);// lazily retrieve from solr cacheif (parentCache != null) {- return parentCache.computeIfAbsent(query, QueryBitSetProducer::new);+ try {+ return parentCache.computeIfAbsent(query, QueryBitSetProducer::new);+ } catch (IOException e) {+ throw new UncheckedIOException(e); // Shouldn't happen because QBSP doesn't throw+ }} else {return new QueryBitSetProducer(query);}diff --git a/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java b/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.javaindex 5ad0b5d137b..e32d6d908b7 100644--- a/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java+++ b/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java@@ -163,13 +163,7 @@ public class RptWithGeometrySpatialField extends AbstractSpatialFieldType<Composthrow new IllegalStateException("Leaf " + readerContext.reader() + " is not suited for caching");}PerSegCacheKey key = new PerSegCacheKey(cacheHelper.getKey(), docId);- Shape shape = cache.computeIfAbsent(key, k -> {- try {- return targetFuncValues.value();- } catch (IOException e) {- return null;- }- });+ Shape shape = cache.computeIfAbsent(key, k -> targetFuncValues.value());if (shape != null) {//optimize shape on a cache hit if possible. This must be thread-safe and it is.if (shape instanceof JtsGeometry) {diff --git a/solr/core/src/java/org/apache/solr/search/CaffeineCache.java b/solr/core/src/java/org/apache/solr/search/CaffeineCache.javaindex f12a3a0c207..cce7c211303 100644--- a/solr/core/src/java/org/apache/solr/search/CaffeineCache.java+++ b/solr/core/src/java/org/apache/solr/search/CaffeineCache.java@@ -17,6 +17,7 @@package org.apache.solr.search;import java.io.IOException;+import java.io.UncheckedIOException;import java.lang.invoke.MethodHandles;import java.time.Duration;import java.util.Collections;@@ -25,14 +26,16 @@ import java.util.Map;import java.util.Map.Entry;import java.util.Optional;import java.util.Set;+import java.util.concurrent.CompletableFuture;+import java.util.concurrent.CompletionException;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.Executor;import java.util.concurrent.ExecutorService;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.LongAdder;-import java.util.function.Function;+import com.github.benmanes.caffeine.cache.AsyncCache;import com.github.benmanes.caffeine.cache.RemovalCause;import com.github.benmanes.caffeine.cache.RemovalListener;import org.apache.lucene.util.Accountable;@@ -40,6 +43,7 @@ import org.apache.lucene.util.RamUsageEstimator;import org.apache.solr.common.SolrException;import org.apache.solr.metrics.MetricsMap;import org.apache.solr.metrics.SolrMetricsContext;+import org.apache.solr.util.IOFunction;import org.slf4j.Logger;import org.slf4j.LoggerFactory;@@ -72,20 +76,28 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, V+ RamUsageEstimator.shallowSizeOfInstance(CacheStats.class)+ 2 * RamUsageEstimator.shallowSizeOfInstance(LongAdder.class);+ private static final long RAM_BYTES_PER_FUTURE = RamUsageEstimator.shallowSizeOfInstance(CompletableFuture.class);+private Executor executor;private CacheStats priorStats;+ private long priorHits;private long priorInserts;+ private long priorLookups;private String description = "Caffeine Cache";+ private LongAdder hits;private LongAdder inserts;+ private LongAdder lookups;private Cache<K,V> cache;+ private AsyncCache<K, V> asyncCache;private long warmupTime;private int maxSize;private long maxRamBytes;private int initialSize;private int maxIdleTimeSec;private boolean cleanupThread;+ private boolean async;private Set<String> metricNames = ConcurrentHashMap.newKeySet();private MetricsMap cacheMap;@@ -103,7 +115,7 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, Vsuper.init(args, regenerator);String str = args.get(SIZE_PARAM);maxSize = (str == null) ? 1024 : Integer.parseInt(str);- str = args.get("initialSize");+ str = args.get(INITIAL_SIZE_PARAM);initialSize = Math.min((str == null) ? 1024 : Integer.parseInt(str), maxSize);str = args.get(MAX_IDLE_TIME_PARAM);if (str == null) {@@ -114,9 +126,12 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, Vstr = args.get(MAX_RAM_MB_PARAM);int maxRamMB = str == null ? -1 : Double.valueOf(str).intValue();maxRamBytes = maxRamMB < 0 ? Long.MAX_VALUE : maxRamMB * 1024L * 1024L;- str = args.get(CLEANUP_THREAD_PARAM);- cleanupThread = str != null && Boolean.parseBoolean(str);- if (cleanupThread) {+ cleanupThread = Boolean.parseBoolean(args.get(CLEANUP_THREAD_PARAM));+ async = Boolean.parseBoolean(args.get(ASYNC_PARAM));+ if (async) {+ // We record futures in the map to decrease bucket-lock contention, but need computation handled in same thread+ executor = Runnable::run;+ } else if (cleanupThread) {executor = ForkJoinPool.commonPool();} else {executor = Runnable::run;@@ -125,7 +140,9 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, Vdescription = generateDescription(maxSize, initialSize);cache = buildCache(null);+ hits = new LongAdder();inserts = new LongAdder();+ lookups = new LongAdder();initialRamBytes =RamUsageEstimator.shallowSizeOfInstance(cache.getClass()) +@@ -150,7 +167,13 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, V} else {builder.maximumSize(maxSize);}- Cache<K, V> newCache = builder.build();+ Cache<K, V> newCache;+ if (async) {+ asyncCache = builder.buildAsync();+ newCache = asyncCache.synchronous();+ } else {+ newCache = builder.build();+ }if (prev != null) {newCache.putAll(prev.asMap());}@@ -176,33 +199,94 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, Vreturn cache.getIfPresent(key);}- @Override- public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {- return cache.get(key, k -> {- inserts.increment();- V value = mappingFunction.apply(k);- if (value == null) {- return null;+ private V computeAsync(K key, IOFunction<? super K, ? extends V> mappingFunction) throws IOException {+ CompletableFuture<V> future = new CompletableFuture<>();+ CompletableFuture<V> result = asyncCache.asMap().putIfAbsent(key, future);+ lookups.increment();+ if (result != null) {+ try {+ // Another thread is already working on this computation, wait for them to finish+ V value = result.join();+ hits.increment();+ return value;+ } catch (CompletionException e) {+ Throwable cause = e.getCause();+ if (cause instanceof IOException) {+ // Computation had an IOException, likely index problems, so fail this result too+ throw (IOException) cause;+ }+ if (cause instanceof CancellableCollector.QueryCancelledException) {+ // The reserved slot that we were waiting for got cancelled, so we will compute directly+ // If we go back to waiting for a new cache result then that can lead to thread starvation+ // Should we record a cache miss here?+ return mappingFunction.apply(key);+ }+ throw e;}- ramBytes.add(RamUsageEstimator.sizeOfObject(key, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED) +- RamUsageEstimator.sizeOfObject(value, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED));- ramBytes.add(RamUsageEstimator.LINKED_HASHTABLE_RAM_BYTES_PER_ENTRY);+ }+ try {+ // We reserved the slot, so we do the work+ V value = mappingFunction.apply(key);+ future.complete(value); // This will update the weight and expiration+ recordRamBytes(key, null, value);+ inserts.increment();return value;- });+ } catch (RuntimeException | IOException e) {+ // TimeExceeded exception is runtime and will bubble up from here+ future.completeExceptionally(e); // This will remove the future from the cache+ throw e;+ }+ }++ @Override+ public V computeIfAbsent(K key, IOFunction<? super K, ? extends V> mappingFunction) throws IOException {+ if (async) {+ return computeAsync(key, mappingFunction);+ }++ try {+ return cache.get(key, k -> {+ V value;+ try {+ value = mappingFunction.apply(k);+ } catch (IOException e) {+ throw new UncheckedIOException(e);+ }+ if (value == null) {+ return null;+ }+ recordRamBytes(key, null, value);+ inserts.increment();+ return value;+ });+ } catch (UncheckedIOException e) {+ throw e.getCause();+ }}@Overridepublic V put(K key, V val) {inserts.increment();V old = cache.asMap().put(key, val);+ recordRamBytes(key, old, val);+ return old;+ }++ /**+ * Update the estimate of used memory+ * @param key the cache key+ * @param oldValue the old cached value to decrement estimate (can be null)+ * @param newValue the new cached value to increment estimate+ */+ private void recordRamBytes(K key, V oldValue, V newValue) {ramBytes.add(RamUsageEstimator.sizeOfObject(key, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED) +- RamUsageEstimator.sizeOfObject(val, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED));- if (old != null) {- ramBytes.add(- RamUsageEstimator.sizeOfObject(old, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED));- } else {+ RamUsageEstimator.sizeOfObject(newValue, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED));+ if (oldValue == null) {ramBytes.add(RamUsageEstimator.LINKED_HASHTABLE_RAM_BYTES_PER_ENTRY);+ if (async) ramBytes.add(RAM_BYTES_PER_FUTURE);+ } else {+ ramBytes.add(- RamUsageEstimator.sizeOfObject(oldValue, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED));}- return old;}@Override@@ -300,9 +384,8 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, V// warm entriesif (isAutowarmingOn()) {- Eviction<K, V> policy = other.cache.policy().eviction().get();int size = autowarm.getWarmCount(other.cache.asMap().size());- hottest = policy.hottest(size);+ hottest = other.cache.policy().eviction().map(p -> p.hottest(size)).orElse(Collections.emptyMap());}for (Entry<K, V> entry : hottest.entrySet()) {@@ -318,15 +401,20 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, V}}+ hits.reset();inserts.reset();- priorStats = other.cache.stats().plus(other.priorStats);+ lookups.reset();+ CacheStats oldStats = other.cache.stats();+ priorStats = oldStats.plus(other.priorStats);+ priorHits = oldStats.hitCount() + other.hits.sum() + other.priorHits;priorInserts = other.inserts.sum() + other.priorInserts;+ priorLookups = oldStats.requestCount() + other.lookups.sum() + other.priorLookups;warmupTime = TimeUnit.MILLISECONDS.convert(System.nanoTime() - warmingStartTime, TimeUnit.NANOSECONDS);}/** Returns the description of this cache. */private String generateDescription(int limit, int initialSize) {- return String.format(Locale.ROOT, "TinyLfu Cache(maxSize=%d, initialSize=%d%s)",+ return String.format(Locale.ROOT, "Caffeine Cache(maxSize=%d, initialSize=%d%s)",limit, initialSize, isAutowarmingOn() ? (", " + getAutowarmDescription()) : "");}@@ -364,11 +452,13 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, VcacheMap = new MetricsMap(map -> {if (cache != null) {CacheStats stats = cache.stats();+ long hitCount = stats.hitCount() + hits.sum();long insertCount = inserts.sum();+ long lookupCount = stats.requestCount() + lookups.sum();- map.put(LOOKUPS_PARAM, stats.requestCount());- map.put(HITS_PARAM, stats.hitCount());- map.put(HIT_RATIO_PARAM, stats.hitRate());+ map.put(LOOKUPS_PARAM, lookupCount);+ map.put(HITS_PARAM, hitCount);+ map.put(HIT_RATIO_PARAM, hitRate(hitCount, lookupCount));map.put(INSERTS_PARAM, insertCount);map.put(EVICTIONS_PARAM, stats.evictionCount());map.put(SIZE_PARAM, cache.asMap().size());@@ -377,13 +467,19 @@ public class CaffeineCache<K, V> extends SolrCacheBase implements SolrCache<K, Vmap.put(MAX_RAM_MB_PARAM, getMaxRamMB());CacheStats cumulativeStats = priorStats.plus(stats);- map.put("cumulative_lookups", cumulativeStats.requestCount());- map.put("cumulative_hits", cumulativeStats.hitCount());- map.put("cumulative_hitratio", cumulativeStats.hitRate());+ long cumLookups = priorLookups + lookupCount;+ long cumHits = priorHits + hitCount;+ map.put("cumulative_lookups", cumLookups);+ map.put("cumulative_hits", cumHits);+ map.put("cumulative_hitratio", hitRate(cumHits, cumLookups));map.put("cumulative_inserts", priorInserts + insertCount);map.put("cumulative_evictions", cumulativeStats.evictionCount());}});solrMetricsContext.gauge(cacheMap, true, scope, getCategory().toString());}++ private static double hitRate(long hitCount, long lookupCount) {+ return lookupCount == 0 ? 1.0 : (double) hitCount / lookupCount;+ }}diff --git a/solr/core/src/java/org/apache/solr/search/JoinQuery.java b/solr/core/src/java/org/apache/solr/search/JoinQuery.javaindex e179aeb565d..55b72cae52d 100644--- a/solr/core/src/java/org/apache/solr/search/JoinQuery.java+++ b/solr/core/src/java/org/apache/solr/search/JoinQuery.java@@ -17,7 +17,6 @@package org.apache.solr.search;-import java.io.Closeable;import java.io.IOException;import java.util.ArrayList;import java.util.Arrays;@@ -140,21 +139,9 @@ class JoinQuery extends Query {if (fromRef != null) {final RefCounted<SolrIndexSearcher> ref = fromRef;- info.addCloseHook(new Closeable() {- @Override- public void close() {- ref.decref();- }- });+ info.addCloseHook(ref::decref);}-- info.addCloseHook(new Closeable() {- @Override- public void close() {- fromCore.close();- }- });-+ info.addCloseHook(fromCore);}this.toSearcher = searcher;}diff --git a/solr/core/src/java/org/apache/solr/search/SolrCache.java b/solr/core/src/java/org/apache/solr/search/SolrCache.javaindex 459a927513e..999559ed321 100644--- a/solr/core/src/java/org/apache/solr/search/SolrCache.java+++ b/solr/core/src/java/org/apache/solr/search/SolrCache.java@@ -17,10 +17,10 @@package org.apache.solr.search;import org.apache.solr.core.SolrInfoBean;+import org.apache.solr.util.IOFunction;import java.io.IOException;import java.util.Map;-import java.util.function.Function;/**@@ -41,6 +41,7 @@ public interface SolrCache<K,V> extends SolrInfoBean {String INITIAL_SIZE_PARAM = "initialSize";String CLEANUP_THREAD_PARAM = "cleanupThread";String SHOW_ITEMS_PARAM = "showItems";+ String ASYNC_PARAM = "async";/*** The initialization routine. Instance specific arguments are passed in@@ -105,8 +106,10 @@ public interface SolrCache<K,V> extends SolrInfoBean {* must NOT attempt to modify any mappings in the cache.* @return existing or newly computed value, null if there was no existing value and* it was not possible to compute a new value (in which case the new mapping won't be created).+ * @throws IOException if and only if mappingFunction threw an IOException.+ * A cache mapping will not be created in this case*/- public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction);+ V computeIfAbsent(K key, IOFunction<? super K, ? extends V> mappingFunction) throws IOException;/** :TODO: copy from Map */public void clear();diff --git a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.javaindex 11b26cc4000..23f042e5a1d 100644--- a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java+++ b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java@@ -31,7 +31,6 @@ import java.util.LinkedList;import java.util.List;import java.util.Objects;import java.util.Set;-import java.util.concurrent.atomic.AtomicReference;import java.util.function.Predicate;import java.util.function.Supplier;@@ -221,18 +220,7 @@ public class SolrDocumentFetcher {Document d;if (documentCache != null) {final Set<String> getFields = enableLazyFieldLoading ? fields : null;- AtomicReference<IOException> exceptionRef = new AtomicReference<>();- d = documentCache.computeIfAbsent(i, docId -> {- try {- return docNC(docId, getFields);- } catch (IOException e) {- exceptionRef.set(e);- return null;- }- });- if (exceptionRef.get() != null) {- throw exceptionRef.get();- }+ d = documentCache.computeIfAbsent(i, docId -> docNC(docId, getFields));if (d == null) {// failed to retrieve due to an earlier exception, try again?return docNC(i, fields);diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.javaindex 641d71c3124..2e6e3368353 100644--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java@@ -33,6 +33,7 @@ import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicLong;import java.util.concurrent.atomic.AtomicReference;+import com.codahale.metrics.Gauge;import com.google.common.collect.Iterables;import org.apache.lucene.document.Document;@@ -81,6 +82,7 @@ import org.apache.solr.search.stats.StatsSource;import org.apache.solr.uninverting.UninvertingReader;import org.apache.solr.update.IndexFingerprint;import org.apache.solr.update.SolrIndexConfig;+import org.apache.solr.util.IOFunction;import org.slf4j.Logger;import org.slf4j.LoggerFactory;@@ -804,15 +806,52 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI}// only handle positive (non negative) queries- DocSet getPositiveDocSet(Query q) throws IOException {- DocSet answer;- if (filterCache != null) {- answer = filterCache.get(q);- if (answer != null) return answer;+ DocSet getPositiveDocSet(Query query) throws IOException {+ // TODO duplicated code with getDocSet?+ boolean doCache = filterCache != null;+ if (query instanceof ExtendedQuery) {+ if (!((ExtendedQuery) query).getCache()) {+ doCache = false;+ }+ if (query instanceof WrappedQuery) {+ query = ((WrappedQuery) query).getWrappedQuery();+ }}- answer = getDocSetNC(q, null);- if (filterCache != null) filterCache.put(q, answer);- return answer;++ if (doCache) {+ return getAndCacheDocSet(query);+ }++ return getDocSetNC(query, null);+ }++ /**+ * Attempt to read the query from the filter cache, if not will compute the result and insert back into the cache+ * <p>Callers must ensure that:+ * <ul><li>The query is unwrapped+ * <li>The query has caching enabled+ * <li>The filter cache exists+ * @param query the query to compute.+ * @return the DocSet answer+ */+ private DocSet getAndCacheDocSet(Query query) throws IOException {+ assert !(query instanceof WrappedQuery) : "should have unwrapped";+ assert filterCache != null : "must check for caching before calling this method";++ if (SolrQueryTimeoutImpl.getInstance().isTimeoutEnabled()) {+ // If there is a possibility of timeout for this query, then don't reserve a computation slot. Further, we can't+ // naively wait for an in progress computation to finish, because if we time out before it does then we won't+ // even have partial results to provide. We could possibly wait for the query to finish in parallel with our own+ // results and if they complete first use that instead, but we'll leave that to implement later.+ DocSet answer = filterCache.get(query);+ if (answer != null) {+ return answer;+ }+ answer = getDocSetNC(query, null);+ filterCache.put(query, answer);+ return answer;+ }+ return filterCache.computeIfAbsent(query, q -> getDocSetNC(q, null));}private static Query matchAllDocsQuery = new MatchAllDocsQuery();@@ -1054,14 +1093,17 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrIpublic DocSet getDocSet(DocsEnumState deState) throws IOException {int largestPossible = deState.termsEnum.docFreq();boolean useCache = filterCache != null && largestPossible >= deState.minSetSizeCached;- TermQuery key = null;if (useCache) {- key = new TermQuery(new Term(deState.fieldName, deState.termsEnum.term()));- DocSet result = filterCache.get(key);- if (result != null) return result;+ TermQuery key = new TermQuery(new Term(deState.fieldName, deState.termsEnum.term()));+ return filterCache.computeIfAbsent(key,+ (IOFunction<? super Query, ? extends DocSet>) k -> getResult(deState, largestPossible));}+ return getResult(deState, largestPossible);+ }++ private DocSet getResult(DocsEnumState deState, int largestPossible) throws IOException {int smallSetSize = DocSetUtil.smallSetSize(maxDoc());int scratchSize = Math.min(smallSetSize, largestPossible);if (deState.scratch == null || deState.scratch.length < scratchSize) deState.scratch = new int[scratchSize];@@ -1123,11 +1165,6 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI} else {result = upto == 0 ? DocSet.empty() : new SortedIntDocSet(Arrays.copyOf(docs, upto));}-- if (useCache) {- filterCache.put(key, result);- }-return result;}@@ -1177,12 +1214,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrIQuery absQ = QueryUtils.getAbs(query);boolean positive = absQ == query;- // note: can't use computeIfAbsent because can be recursive- DocSet absAnswer = filterCache.get(absQ);- if (absAnswer == null) {- absAnswer = getDocSetNC(absQ, null);- filterCache.put(absQ, absAnswer);- }+ DocSet absAnswer = getAndCacheDocSet(absQ);if (filter == null) {return positive ? absAnswer : getLiveDocSet().andNot(absAnswer);diff --git a/solr/core/src/java/org/apache/solr/search/facet/UnInvertedField.java b/solr/core/src/java/org/apache/solr/search/facet/UnInvertedField.javaindex a044c8fad15..633ec3980dc 100644--- a/solr/core/src/java/org/apache/solr/search/facet/UnInvertedField.java+++ b/solr/core/src/java/org/apache/solr/search/facet/UnInvertedField.java@@ -24,7 +24,6 @@ import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.concurrent.atomic.AtomicLong;-import java.util.concurrent.atomic.AtomicReference;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;@@ -36,7 +35,6 @@ import org.apache.lucene.util.BytesRef;import org.apache.lucene.util.CharsRefBuilder;import org.apache.lucene.util.FixedBitSet;import org.apache.solr.common.SolrException;-import org.apache.solr.common.SolrException.ErrorCode;import org.apache.solr.index.SlowCompositeReaderWrapper;import org.apache.solr.schema.FieldType;import org.apache.solr.schema.TrieField;@@ -605,80 +603,7 @@ public class UnInvertedField extends DocTermOrds {if (cache == null) {return new UnInvertedField(field, searcher);}- AtomicReference<Throwable> throwableRef = new AtomicReference<>();- UnInvertedField uif = cache.computeIfAbsent(field, f -> {- UnInvertedField newUif;- try {- newUif = new UnInvertedField(field, searcher);- } catch (Throwable t) {- throwableRef.set(t);- newUif = null;- }- return newUif;- });- if (throwableRef.get() != null) {- rethrowAsSolrException(field, throwableRef.get());- }- return uif;-- // (ab) if my understanding is correct this whole block tried to mimic the- // semantics of computeIfAbsent--// Boolean doWait = false;-// synchronized (cache) {-// final Object val = cache.get(field);-// if (val == null || (val instanceof Throwable)) {-// /**-// * We use this place holder object to pull the UninvertedField construction out of the sync-// * so that if many fields are accessed in a short time, the UninvertedField can be-// * built for these fields in parallel rather than sequentially.-// */-// cache.put(field, uifPlaceholder);-// } else {-// if (val != uifPlaceholder) {-// return (UnInvertedField) val;-// }-// doWait = true; // Someone else has put the place holder in, wait for that to complete.-// }-// }-// while (doWait) {-// try {-// synchronized (cache) {-// final Object val = cache.get(field);-// if (val != uifPlaceholder) { // OK, another thread put this in the cache we should be good.-// if (val instanceof Throwable) {-// rethrowAsSolrException(field, (Throwable) val);-// } else {-// return (UnInvertedField) val;-// }-// }-// cache.wait();-// }-// } catch (InterruptedException e) {-// rethrowAsSolrException(field, e);-// }-// }-//-// UnInvertedField uif = null;-// try {-// uif = new UnInvertedField(field, searcher);-// }catch(Throwable e) {-// synchronized (cache) {-// cache.put(field, e); // signaling the failure-// cache.notifyAll();-// }-// rethrowAsSolrException(field, e);-// }-// synchronized (cache) {-// cache.put(field, uif); // Note, this cleverly replaces the placeholder.-// cache.notifyAll();-// }-// return uif;- }-- protected static void rethrowAsSolrException(String field, Throwable e) {- throw new SolrException(ErrorCode.SERVER_ERROR,- "Exception occured during uninverting " + field, e);+ return cache.computeIfAbsent(field, f -> new UnInvertedField(f, searcher));}// Returns null if not already populateddiff --git a/solr/core/src/java/org/apache/solr/search/join/BlockJoinParentQParser.java b/solr/core/src/java/org/apache/solr/search/join/BlockJoinParentQParser.javaindex 151062f2d10..c1557d258da 100644--- a/solr/core/src/java/org/apache/solr/search/join/BlockJoinParentQParser.java+++ b/solr/core/src/java/org/apache/solr/search/join/BlockJoinParentQParser.java@@ -17,6 +17,7 @@package org.apache.solr.search.join;import java.io.IOException;+import java.io.UncheckedIOException;import java.util.Objects;import org.apache.lucene.index.LeafReaderContext;@@ -90,7 +91,11 @@ public class BlockJoinParentQParser extends FiltersQParser {SolrCache<Query, BitSetProducer> parentCache = request.getSearcher().getCache(CACHE_NAME);// lazily retrieve from solr cacheif (parentCache != null) {- return parentCache.computeIfAbsent(query, QueryBitSetProducer::new);+ try {+ return parentCache.computeIfAbsent(query, QueryBitSetProducer::new);+ } catch (IOException e) {+ throw new UncheckedIOException(e); // Shouldn't happen because QBSP doesn't throw+ }} else {return new QueryBitSetProducer(query);}diff --git a/solr/core/src/java/org/apache/solr/search/join/HashRangeQuery.java b/solr/core/src/java/org/apache/solr/search/join/HashRangeQuery.javaindex 35267a028c6..f7730865e07 100644--- a/solr/core/src/java/org/apache/solr/search/join/HashRangeQuery.java+++ b/solr/core/src/java/org/apache/solr/search/join/HashRangeQuery.java@@ -88,19 +88,15 @@ public class HashRangeQuery extends Query {}IndexReader.CacheKey cacheKey = cacheHelper.getKey();- synchronized (cacheKey) {- int[] hashes = cache.get(cacheKey);- if (hashes == null) {- hashes = new int[context.reader().maxDoc()];- SortedDocValues docValues = context.reader().getSortedDocValues(field);- int doc;- while ((doc = docValues.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {- hashes[doc] = hash(docValues);- }- cache.put(cacheKey, hashes);+ return cache.computeIfAbsent(cacheKey, ck -> {+ int[] hashes = new int[context.reader().maxDoc()];+ SortedDocValues docValues = context.reader().getSortedDocValues(field);+ int doc;+ while ((doc = docValues.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {+ hashes[doc] = hash(docValues);}return hashes;- }+ });}private int hash(SortedDocValues docValues) throws IOException {diff --git a/solr/core/src/java/org/apache/solr/util/TestInjection.java b/solr/core/src/java/org/apache/solr/util/TestInjection.javaindex eee966dbd2d..0e62c994714 100644--- a/solr/core/src/java/org/apache/solr/util/TestInjection.java+++ b/solr/core/src/java/org/apache/solr/util/TestInjection.java@@ -149,6 +149,10 @@ public class TestInjection {public volatile static Integer delayInExecutePlanAction=null;+ public volatile static Integer delayBeforeCreatingNewDocSet = null;++ public volatile static AtomicInteger countDocSetDelays = new AtomicInteger(0);+public volatile static boolean failInExecutePlanAction = false;/**@@ -190,6 +194,8 @@ public class TestInjection {wrongIndexFingerprint = null;delayBeforeFollowerCommitRefresh = null;delayInExecutePlanAction = null;+ delayBeforeCreatingNewDocSet = null;+ countDocSetDelays.set(0);failInExecutePlanAction = false;skipIndexWriterCommitOnClose = false;uifOutOfMemoryError = false;@@ -576,6 +582,22 @@ public class TestInjection {return true;}+ public static boolean injectDocSetDelay() {+ if (delayBeforeCreatingNewDocSet != null) {+ countDocSetDelays.incrementAndGet();+ try {+ log.info("Pausing DocSet for {}ms", delayBeforeCreatingNewDocSet);+ if (log.isDebugEnabled()) {+ log.debug("", new Exception("Stack Trace"));+ }+ Thread.sleep(delayBeforeCreatingNewDocSet);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ }+ return true;+ }+static Set<Hook> newSearcherHooks = ConcurrentHashMap.newKeySet();public interface Hook {diff --git a/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml b/solr/core/src/test-files/solr/collection1/conf/solrconfig.xmlindex c6b80c75ee1..d46a8b7f52a 100644--- a/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml+++ b/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml@@ -97,7 +97,8 @@<filterCachesize="512"initialSize="512"- autowarmCount="2"/>+ autowarmCount="2"+ async="${solr.filterCache.async:false}"/><queryResultCachesize="512"diff --git a/solr/core/src/test/org/apache/solr/request/TestUnInvertedFieldException.java b/solr/core/src/test/org/apache/solr/request/TestUnInvertedFieldException.javaindex f927baf5476..b035826cd9c 100644--- a/solr/core/src/test/org/apache/solr/request/TestUnInvertedFieldException.java+++ b/solr/core/src/test/org/apache/solr/request/TestUnInvertedFieldException.java@@ -32,7 +32,6 @@ import org.apache.lucene.util.NamedThreadFactory;import org.apache.lucene.util.TestUtil;import org.apache.solr.SolrTestCaseJ4;import org.apache.solr.common.SolrException;-import org.apache.solr.common.SolrException.ErrorCode;import org.apache.solr.common.util.ExecutorUtil.MDCAwareThreadPoolExecutor;import org.apache.solr.search.SolrIndexSearcher;import org.apache.solr.search.facet.UnInvertedField;@@ -96,13 +95,9 @@ public class TestUnInvertedFieldException extends SolrTestCaseJ4 {List<Future<UnInvertedField>> futures = initCallables.stream().map((c) -> pool.submit(c)).collect(Collectors.toList());for (Future<UnInvertedField> uifuture : futures) {- try {- final UnInvertedField uif = uifuture.get();- } catch (ExecutionException injection) {- SolrException solrException = (SolrException) injection.getCause();- assertEquals(ErrorCode.SERVER_ERROR.code, solrException.code());- assertSame(solrException.getCause().getClass(), OutOfMemoryError.class);- }+ ExecutionException injection = assertThrows(ExecutionException.class, uifuture::get);+ Throwable root = SolrException.getRootCause(injection);+ assertSame(OutOfMemoryError.class, root.getClass());assertNull(UnInvertedField.checkUnInvertedField(proto.field(), searcher));}TestInjection.uifOutOfMemoryError = false;diff --git a/solr/core/src/test/org/apache/solr/search/TestRangeQuery.java b/solr/core/src/test/org/apache/solr/search/TestRangeQuery.javaindex 5eb182870b6..fc2689f7f42 100644--- a/solr/core/src/test/org/apache/solr/search/TestRangeQuery.java+++ b/solr/core/src/test/org/apache/solr/search/TestRangeQuery.java@@ -25,18 +25,27 @@ import java.util.HashMap;import java.util.List;import java.util.Locale;import java.util.Map;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.TimeUnit;import com.carrotsearch.hppc.IntHashSet;import org.apache.lucene.util.TestUtil;import org.apache.solr.SolrTestCaseJ4;import org.apache.solr.common.SolrInputDocument;import org.apache.solr.common.params.ModifiableSolrParams;+import org.apache.solr.common.util.ExecutorUtil;+import org.apache.solr.common.util.SolrNamedThreadFactory;+import org.apache.solr.core.SolrCore;import org.apache.solr.request.SolrQueryRequest;+import org.apache.solr.request.SolrRequestHandler;import org.apache.solr.response.ResultContext;import org.apache.solr.response.SolrQueryResponse;import org.apache.solr.schema.FieldType;import org.apache.solr.schema.NumberType;import org.apache.solr.schema.StrField;+import org.apache.solr.util.TestInjection;+import org.junit.After;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;@@ -61,6 +70,13 @@ public class TestRangeQuery extends SolrTestCaseJ4 {assertU(commit());}+ @After+ @Override+ public void tearDown() throws Exception {+ TestInjection.reset();+ super.tearDown();+ }+void addInt(SolrInputDocument doc, int l, int u, String... fields) {int v=0;if (0==l && l==u) {@@ -81,9 +97,12 @@ public class TestRangeQuery extends SolrTestCaseJ4 {for (int i=0; i<nDocs; i++) {SolrInputDocument doc = new SolrInputDocument();doc.addField("id", ""+i);- proc.process(doc);+ if (proc != null) {+ proc.process(doc);+ }assertU(adoc(doc));}+ assertU(commit());}@Test@@ -260,14 +279,10 @@ public class TestRangeQuery extends SolrTestCaseJ4 {// sometimes a very small index, sometimes a very large indexfinal int numDocs = random().nextBoolean() ? random().nextInt(50) : atLeast(1000);- createIndex(numDocs, new DocProcessor() {- @Override- public void process(SolrInputDocument doc) {- // 10% of the docs have missing values- if (random().nextInt(10)!=0) addInt(doc, l,u, fields);- }+ createIndex(numDocs, doc -> {+ // 10% of the docs have missing values+ if (random().nextInt(10)!=0) addInt(doc, l,u, fields);});- assertU(commit());final int numIters = atLeast(1000);for (int i=0; i < numIters; i++) {@@ -357,7 +372,46 @@ public class TestRangeQuery extends SolrTestCaseJ4 {}}}-++ @Test+ public void testRangeQueryWithFilterCache() throws Exception {+ TestInjection.delayBeforeCreatingNewDocSet = 500;++ // sometimes a very small index, sometimes a very large index+ // final int numDocs = random().nextBoolean() ? random().nextInt(50) : atLeast(1000);+ final int numDocs = 99;+ createIndex(numDocs, doc -> {+ addInt(doc, 0, 0, "foo_i");+ });++ ExecutorService queryService = ExecutorUtil.newMDCAwareFixedThreadPool(4, new SolrNamedThreadFactory("TestRangeQuery"));+ try (SolrCore core = h.getCoreInc()) {+ SolrRequestHandler defaultHandler = core.getRequestHandler("");++ ModifiableSolrParams params = new ModifiableSolrParams();+ params.set("q", "*:*");+ params.add("fq", "id:[0 TO 222]"); // These should all come from FilterCache++ // 10 threads with 4 executors would be enough for 3 waves, or approximately 1500ms of delay+ CountDownLatch atLeastOnceCompleted = new CountDownLatch(1);+ for (int i = 0; i < 10; i++) {+ queryService.submit(() -> {+ try (SolrQueryRequest req = req(params)) {+ core.execute(defaultHandler, req, new SolrQueryResponse());+ }+ atLeastOnceCompleted.countDown();+ });+ }++ queryService.shutdown(); // No more requests will be queued up+ atLeastOnceCompleted.await(); // Wait for the first query to complete+ assertTrue(queryService.awaitTermination(1, TimeUnit.SECONDS)); // All queries after should be very fast++ assertEquals("Create only one DocSet outside of cache", 1, TestInjection.countDocSetDelays.get());+ }+ }++ @Testpublic void testRangeQueryEndpointTO() throws Exception {assertEquals("[to TO to]", QParser.getParser("[to TO to]", req("df", "text")).getQuery().toString("text"));assertEquals("[to TO to]", QParser.getParser("[to TO TO]", req("df", "text")).getQuery().toString("text"));@@ -377,6 +431,7 @@ public class TestRangeQuery extends SolrTestCaseJ4 {assertEquals("[xx TO to]", QParser.getParser("[xx TO TO]", req("df", "text")).getQuery().toString("text"));}+ @Testpublic void testRangeQueryRequiresTO() throws Exception {assertEquals("{a TO b}", QParser.getParser("{A TO B}", req("df", "text")).getQuery().toString("text"));assertEquals("[a TO b}", QParser.getParser("[A TO B}", req("df", "text")).getQuery().toString("text"));@@ -400,6 +455,7 @@ public class TestRangeQuery extends SolrTestCaseJ4 {expectThrows(SyntaxError.class, () -> QParser.getParser("[A TO]", req("df", "text")).getQuery());}+ @Testpublic void testCompareTypesRandomRangeQueries() throws Exception {int cardinality = 10000;Map<NumberType,String[]> types = new HashMap<>(); //single and multivalued field types@@ -503,13 +559,9 @@ public class TestRangeQuery extends SolrTestCaseJ4 {private long doRangeQuery(boolean mv, String start, String end, String field, String[] qRange) throws Exception {ModifiableSolrParams params = new ModifiableSolrParams();params.set("q", "field_" + (mv?"mv_":"sv_") + field + ":" + start + qRange[0] + " TO " + qRange[1] + end);- SolrQueryRequest req = req(params);- try {+ try (SolrQueryRequest req = req(params)) {return (long) h.queryAndResponse("", req).getToLog().get("hits");- } finally {- req.close();}-}private String[] getRandomRange(int max, String fieldName) {diff --git a/solr/core/src/test/org/apache/solr/search/TestSolrCachePerf.java b/solr/core/src/test/org/apache/solr/search/TestSolrCachePerf.javaindex f46ba60dc09..63111d1f401 100644--- a/solr/core/src/test/org/apache/solr/search/TestSolrCachePerf.java+++ b/solr/core/src/test/org/apache/solr/search/TestSolrCachePerf.java@@ -16,10 +16,13 @@*/package org.apache.solr.search;+import java.io.IOException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;+import java.util.Set;+import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.CountDownLatch;import java.util.concurrent.atomic.AtomicBoolean;@@ -30,6 +33,7 @@ import org.apache.solr.metrics.SolrMetricManager;import org.apache.solr.metrics.SolrMetricsContext;import org.junit.Before;import org.junit.Test;+import org.junit.runners.model.MultipleFailureException;/***@@ -61,8 +65,8 @@ public class TestSolrCachePerf extends SolrTestCaseJ4 {// warm-upint threads = 10;for (int i = 0; i < 10; i++) {- doTestGetPutCompute(new HashMap<String, SummaryStatistics>(), new HashMap<String, SummaryStatistics>(), threads, false);- doTestGetPutCompute(new HashMap<String, SummaryStatistics>(), new HashMap<String, SummaryStatistics>(), threads, true);+ doTestGetPutCompute(new HashMap<>(), new HashMap<>(), threads, false);+ doTestGetPutCompute(new HashMap<>(), new HashMap<>(), threads, true);}for (int i = 0; i < 100; i++) {doTestGetPutCompute(getPutRatio, getPutTime, threads, false);@@ -104,6 +108,7 @@ public class TestSolrCachePerf extends SolrTestCaseJ4 {CountDownLatch startLatch = new CountDownLatch(1);CountDownLatch stopLatch = new CountDownLatch(numThreads * NUM_KEYS);List<Thread> runners = new ArrayList<>();+ Set<Exception> exceptions = ConcurrentHashMap.newKeySet();for (int i = 0; i < numThreads; i++) {Thread t = new Thread(() -> {try {@@ -124,11 +129,10 @@ public class TestSolrCachePerf extends SolrTestCaseJ4 {}}Thread.yield();- stopLatch.countDown();+ stopLatch.countDown(); // Does this need to be in a finally block?}- } catch (InterruptedException e) {- fail(e.toString());- return;+ } catch (InterruptedException | IOException e) {+ exceptions.add(e);}});t.start();@@ -142,6 +146,9 @@ public class TestSolrCachePerf extends SolrTestCaseJ4 {for (Thread t : runners) {t.join();}+ if (! exceptions.isEmpty()) {+ throw new MultipleFailureException(new ArrayList<>(exceptions));+ }long stopTime = System.nanoTime();Map<String, Object> metrics = cache.getSolrMetricsContext().getMetricsSnapshot();perImplRatio.addValue(diff --git a/solr/core/src/test/org/apache/solr/search/TestSolrQueryParser.java b/solr/core/src/test/org/apache/solr/search/TestSolrQueryParser.javaindex 2a90327a57e..39bf5d8db58 100644--- a/solr/core/src/test/org/apache/solr/search/TestSolrQueryParser.java+++ b/solr/core/src/test/org/apache/solr/search/TestSolrQueryParser.java@@ -572,16 +572,16 @@ public class TestSolrQueryParser extends SolrTestCaseJ4 {);inserts += 3;- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());assertJQ(req("q", "doesnotexist2 filter(id:1) filter(qqq_s:X) filter(abcdefg)"), "/response/numFound==2");hits += 3;- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());// make sure normal "fq" parameters also hit the cache the same wayassertJQ(req("q", "doesnotexist3", "fq", "id:1", "fq", "qqq_s:X", "fq", "abcdefg")@@ -589,8 +589,8 @@ public class TestSolrQueryParser extends SolrTestCaseJ4 {);hits += 3;- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());// try a query deeply nested in a FQassertJQ(req("q", "*:* doesnotexist4", "fq", "(id:* +(filter(id:1) filter(qqq_s:X) filter(abcdefg)) )")@@ -599,8 +599,8 @@ public class TestSolrQueryParser extends SolrTestCaseJ4 {inserts += 1; // +1 for top level fqhits += 3;- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());// retry the complex FQ and make sure hashCode/equals works as expected w/ filter queriesassertJQ(req("q", "*:* doesnotexist5", "fq", "(id:* +(filter(id:1) filter(qqq_s:X) filter(abcdefg)) )")@@ -608,8 +608,8 @@ public class TestSolrQueryParser extends SolrTestCaseJ4 {);hits += 1; // top-level fq should have been found.- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());// try nested filter with multiple top-level args (i.e. a boolean query)@@ -619,8 +619,8 @@ public class TestSolrQueryParser extends SolrTestCaseJ4 {hits += 1; // the inner filterinserts += 1; // the outer filter- assertEquals(inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());- assertEquals(hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());+ assertEquals("wrong number of inserts", inserts, ((Long) filterCacheStats.getValue().get("inserts")).longValue());+ assertEquals("wrong number of hits", hits, ((Long) filterCacheStats.getValue().get("hits")).longValue());// test the score for a filter, and that default score is 0assertJQ(req("q", "+filter(*:*) +filter(id:1)", "fl", "id,score", "sort", "id asc")diff --git a/solr/core/src/test/org/apache/solr/search/join/BJQParserTest.java b/solr/core/src/test/org/apache/solr/search/join/BJQParserTest.javaindex c56356324d5..6e9f35d4685 100644--- a/solr/core/src/test/org/apache/solr/search/join/BJQParserTest.java+++ b/solr/core/src/test/org/apache/solr/search/join/BJQParserTest.java@@ -325,9 +325,10 @@ public class BJQParserTest extends SolrTestCaseJ4 {assertEquals("the first lookup gets insert", 1,delta("inserts", parentFilterCache.getValue(), parentsBefore));-+ assertEquals("true join query was not in fqCache", 0L,+ delta("hits", filterCache.getValue(), filtersBefore));assertEquals("true join query is cached in fqCache", 1L,- delta("lookups", filterCache.getValue(), filtersBefore));+ delta("inserts", filterCache.getValue(), filtersBefore));}private long delta(String key, Map<String,Object> a, Map<String,Object> b) {diff --git a/solr/licenses/caffeine-2.8.4.jar.sha1 b/solr/licenses/caffeine-2.8.4.jar.sha1deleted file mode 100644index 813e00d57d0..00000000000--- a/solr/licenses/caffeine-2.8.4.jar.sha1+++ /dev/null@@ -1 +0,0 @@-e5730b11981406faa28e0912405a0ce7c2d0f377diff --git a/solr/licenses/caffeine-2.9.2.jar.sha1 b/solr/licenses/caffeine-2.9.2.jar.sha1new file mode 100644index 00000000000..032dd105965--- /dev/null+++ b/solr/licenses/caffeine-2.9.2.jar.sha1@@ -0,0 +1 @@+0a17ed335e0ce2d337750772c0709b79af35a842diff --git a/solr/solr-ref-guide/src/caches-warming.adoc b/solr/solr-ref-guide/src/caches-warming.adocindex 52678d39b8e..9ba30ce197d 100644--- a/solr/solr-ref-guide/src/caches-warming.adoc+++ b/solr/solr-ref-guide/src/caches-warming.adoc@@ -79,6 +79,9 @@ Reasonable values, depending on the query volume and patterns, may lie somewhereThe `maxRamMB` attribute limits the maximum amount of memory a cache may consume.When both `size` and `maxRamMB` limits are specified the `maxRamMB` limit will take precedence and the `size` limit will be ignored.+The `async` attribute determines whether the cache stores direct results (`async=false`, the default) or whether it will store indirect references to the computation (`async=true`). Enabling `async` will use more slightly more memory per cache entry, but may result in reduced CPU cycles generating results or doing garbage collection. The most noticable improvements will be seen when there are many queries racing to compute the same results before they are inserted into the cache. In some use cases, increasing autowarming may be a better alternative to enabling an async cache. Additionally, an async cache will not prevent a data race for time-limited queries, as those may return differing sets of partial results.+This value is most effective on a filter cache, and likely less relevant on the other cache usages.+All caches can be disabled using the parameter `enabled` with a value of `false`.Caches can also be disabled on a query-by-query basis with the `cache` parameter, as described in the section <<common-query-parameters.adoc#cache-local-parameter,cache Local Parameter>>.@@ -118,6 +121,17 @@ Therefore, the `size` parameter is ignored if `maxRamMB` is specified.autowarmCount="128"/>----+The filter cache is a good candidate for enabling `async` computation.++[source,xml]+----+<filterCache class="solr.CaffeineCache"+ size="1024"+ autowarmCount="0"+ async="true"/>+----++=== Query Result CacheThe `queryResultCache` holds the results of previous searches: ordered lists of document IDs (DocList) based on a query, a sort, and the range of documents requested.diff --git a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.javaindex 1a786fbea63..f438f35a420 100644--- a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java+++ b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java@@ -300,10 +300,11 @@ public abstract class SolrTestCaseJ4 extends SolrTestCase {System.setProperty("solr.v2RealPath", "true");System.setProperty("zookeeper.forceSync", "no");System.setProperty("jetty.testMode", "true");- System.setProperty("enable.update.log", usually() ? "true" : "false");+ System.setProperty("enable.update.log", Boolean.toString(usually()));System.setProperty("tests.shardhandler.randomSeed", Long.toString(random().nextLong()));System.setProperty("solr.clustering.enabled", "false");System.setProperty("solr.cloud.wait-for-updates-with-stale-state-pause", "500");+ System.setProperty("solr.filterCache.async", Boolean.toString(usually()));System.setProperty("pkiHandlerPrivateKeyPath", SolrTestCaseJ4.class.getClassLoader().getResource("cryptokeys/priv_key512_pkcs8.pem").toExternalForm());System.setProperty("pkiHandlerPublicKeyPath", SolrTestCaseJ4.class.getClassLoader().getResource("cryptokeys/pub_key512.der").toExternalForm());diff --git a/versions.lock b/versions.lockindex 2aa1e6f68d8..6960cb01ce4 100644--- a/versions.lock+++ b/versions.lock@@ -12,7 +12,7 @@ com.fasterxml.jackson.core:jackson-core:2.12.3 (11 constraints: 61e504fa)com.fasterxml.jackson.core:jackson-databind:2.12.3 (19 constraints: f3595e4c)com.fasterxml.jackson.dataformat:jackson-dataformat-smile:2.12.3 (2 constraints: ed13c981)com.fasterxml.woodstox:woodstox-core:6.2.4 (2 constraints: 4d1cac9f)-com.github.ben-manes.caffeine:caffeine:2.8.4 (1 constraints: 10051136)+com.github.ben-manes.caffeine:caffeine:2.9.2 (1 constraints: 0f051236)com.github.virtuald:curvesapi:1.06 (1 constraints: db04f530)com.github.zafarkhaja:java-semver:0.9.0 (1 constraints: 0b050636)com.google.api:api-common:1.10.1 (4 constraints: 822c34f6)diff --git a/versions.props b/versions.propsindex 39f7ee8e219..2c71a28b947 100644--- a/versions.props+++ b/versions.props@@ -8,7 +8,7 @@ com.epam:parso=2.0.11com.esri.geometry:esri-geometry-api=2.2.0com.fasterxml.jackson*:*=2.10.1com.fasterxml.woodstox:woodstox-core=6.2.4-com.github.ben-manes.caffeine:caffeine=2.8.4+com.github.ben-manes.caffeine:caffeine=2.9.2com.github.virtuald:curvesapi=1.06com.github.zafarkhaja:java-semver=0.9.0com.google.api-client:google-api-client=1.29.2