magibney commented on a change in pull request #592:
URL: https://github.com/apache/solr/pull/592#discussion_r838950285
##########
File path: solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
##########
@@ -935,22 +956,96 @@ private DocSet getAndCacheDocSet(Query query) throws
IOException {
return filterCache.computeIfAbsent(query, q -> getDocSetNC(q, null));
}
- private static Query matchAllDocsQuery = new MatchAllDocsQuery();
- private volatile BitDocSet liveDocs;
+ private static final MatchAllDocsQuery MATCH_ALL_DOCS_QUERY = new
MatchAllDocsQuery();
+
+ /**
+ * A naively cached canonical `liveDocs` DocSet. This does not need to be
volatile. It may be set
+ * multiple times, but should always be set to the same value, as all set
values should pass
+ * through `liveDocsCache.computeIfAbsent`
+ */
+ private BitDocSet liveDocs;
+
+ private static final BitDocSet EMPTY = new BitDocSet(new FixedBitSet(0), 0);
+
+ private BitDocSet computeLiveDocs() {
+ switch (leafContexts.size()) {
+ case 0:
+ assert numDocs() == 0;
+ return EMPTY;
+ case 1:
+ final Bits onlySegLiveDocs =
leafContexts.get(0).reader().getLiveDocs();
+ final FixedBitSet fbs;
+ if (onlySegLiveDocs == null) {
+ // `LeafReader.getLiveDocs()` returns null if no deleted docs --
accordingly, set all bits
+ final int onlySegMaxDoc = maxDoc();
+ fbs = new FixedBitSet(onlySegMaxDoc);
+ fbs.set(0, onlySegMaxDoc);
+ } else {
+ fbs = FixedBitSet.copyOf(onlySegLiveDocs);
+ }
+ assert fbs.cardinality() == numDocs();
+ return new BitDocSet(fbs, numDocs());
+ default:
+ final FixedBitSet bs = new FixedBitSet(maxDoc());
+ for (LeafReaderContext ctx : leafContexts) {
+ final LeafReader r = ctx.reader();
+ final Bits segLiveDocs = r.getLiveDocs();
+ final int segDocBase = ctx.docBase;
+ if (segLiveDocs == null) {
+ // `LeafReader.getLiveDocs()` returns null if no deleted docs --
accordingly, set all
+ // bits in seg range
+ bs.set(segDocBase, segDocBase + r.maxDoc());
+ } else {
+ DocSetUtil.copyTo(segLiveDocs, 0, r.maxDoc(), bs, segDocBase);
+ }
+ }
+ assert bs.cardinality() == numDocs();
+ return new BitDocSet(bs, numDocs());
+ }
+ }
+
+ private BitDocSet populateLiveDocs(Supplier<BitDocSet> liveDocsSupplier) {
+ final boolean computeInline;
+ final CompletableFuture<BitDocSet> liveDocsCacheInstance;
+ synchronized (liveDocsCache) {
+ if (liveDocsCache[0] != null) {
+ computeInline = false;
+ liveDocsCacheInstance = liveDocsCache[0];
+ } else {
+ computeInline = true;
+ liveDocsCacheInstance = new CompletableFuture<>();
+ liveDocsCache[0] = liveDocsCacheInstance;
+ }
+ }
+ final BitDocSet docs;
+ if (computeInline) {
+ docs = liveDocsSupplier.get();
+ liveDocsCacheInstance.complete(docs);
+ liveDocs = docs;
+ liveDocsInsertsCount.increment();
+ } else {
Review comment:
I think you're right. And I think you don't even lose on concurrency
gains:
In both cases execution blocks until the result is available. It doesn't
matter whether you're blocking for a synchronized lock or on getting results
from the Future. The only way it matters is if you're attempting to make a
distinction between "I'm waiting because a computation is in progress" and "I
had to get a lock on the object that will ensure computation has completed". So
if we lose the "asyncHits" metric (I'm fine with that), then things can be much
simpler.
Tried this out with b3b38a1b2e280febd6a4a86464fad36bea4c56b8 ... seems good
to me?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@solr.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@solr.apache.org
For additional commands, e-mail: issues-h...@solr.apache.org
