Skip to content

Apache Lucene open-source search software

remove IndexReader.registerParentReader() (#15002)

Robert Muir96f862dfb816
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 633b85d9ea8..ec480d59f2c 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -50,6 +50,10 @@ Improvements
global queue min-score checking. Improves performance and consistency. (Mike Sokolov, Dzung Bui,
Ben Trent)
+* GITHUB#15002: Remove synchronized WeakHashMap from IndexReader. This was added to help prevent
+ SIGSEGV with the old unsafe "mmap hack", which has been replaced by MemorySegments.
+ (Uwe Schindler, Robert Muir)
+
Optimizations
---------------------
* GITHUB#14011: Reduce allocation rate in HNSW concurrent merge. (Viliam Durina)
diff --git a/lucene/core/src/java/org/apache/lucene/index/BaseCompositeReader.java b/lucene/core/src/java/org/apache/lucene/index/BaseCompositeReader.java
index dcda91a4c5d..d3ae0c2ae11 100644
--- a/lucene/core/src/java/org/apache/lucene/index/BaseCompositeReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/BaseCompositeReader.java
@@ -84,7 +84,6 @@ public abstract class BaseCompositeReader<R extends IndexReader> extends Composi
starts[i] = (int) maxDoc;
final IndexReader r = subReaders[i];
maxDoc += r.maxDoc(); // compute maxDocs
- r.registerParentReader(this);
}
if (maxDoc > IndexWriter.getActualMaxDocs()) {
diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
index 87d62f22d04..8f1edf4962e 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
@@ -334,7 +334,6 @@ public abstract class FilterLeafReader extends LeafReader {
throw new NullPointerException("incoming LeafReader must not be null");
}
this.in = in;
- in.registerParentReader(this);
}
@Override
diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexReader.java b/lucene/core/src/java/org/apache/lucene/index/IndexReader.java
index 8e965ee8099..f14b36ac89a 100644
--- a/lucene/core/src/java/org/apache/lucene/index/IndexReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/IndexReader.java
@@ -18,10 +18,7 @@ package org.apache.lucene.index;
import java.io.Closeable;
import java.io.IOException;
-import java.util.Collections;
import java.util.List;
-import java.util.Set;
-import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.lucene.store.AlreadyClosedException;
@@ -146,24 +143,6 @@ public abstract sealed class IndexReader implements Closeable permits CompositeR
void onClose(CacheKey key) throws IOException;
}
- private final Set<IndexReader> parentReaders =
- Collections.synchronizedSet(
- Collections.newSetFromMap(new WeakHashMap<IndexReader, Boolean>()));
-
- /**
- * Expert: This method is called by {@code IndexReader}s which wrap other readers (e.g. {@link
- * CompositeReader} or {@link FilterLeafReader}) to register the parent at the child (this reader)
- * on construction of the parent. When this reader is closed, it will mark all registered parents
- * as closed, too. The references to parent readers are weak only, so they can be GCed once they
- * are no longer in use.
- *
- * @lucene.experimental
- */
- public final void registerParentReader(IndexReader reader) {
- ensureOpen();
- parentReaders.add(reader);
- }
-
/**
* For test framework use only.
*
@@ -173,18 +152,6 @@ public abstract sealed class IndexReader implements Closeable permits CompositeR
// nothing to notify in the base impl
}
- private void reportCloseToParentReaders() throws IOException {
- synchronized (parentReaders) {
- for (IndexReader parent : parentReaders) {
- parent.closedByChild = true;
- // cross memory barrier by a fake write:
- parent.refCount.addAndGet(0);
- // recurse:
- parent.reportCloseToParentReaders();
- }
- }
- }
-
/** Expert: returns the current refCount for this reader */
public final int getRefCount() {
// NOTE: don't ensureOpen, so that callers can see
@@ -253,8 +220,7 @@ public abstract sealed class IndexReader implements Closeable permits CompositeR
final int rc = refCount.decrementAndGet();
if (rc == 0) {
closed = true;
- try (Closeable _ = this::reportCloseToParentReaders;
- Closeable _ = this::notifyReaderClosedListeners) {
+ try (Closeable _ = this::notifyReaderClosedListeners) {
doClose();
}
} else if (rc < 0) {
diff --git a/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java
index d73f111785a..f96c5174f37 100644
--- a/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/ParallelLeafReader.java
@@ -196,7 +196,6 @@ public class ParallelLeafReader extends LeafReader {
if (!closeSubReaders) {
reader.incRef();
}
- reader.registerParentReader(this);
}
}
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestReaderClosed.java b/lucene/core/src/test/org/apache/lucene/index/TestReaderClosed.java
index ac23b9b5287..694aefd4e73 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestReaderClosed.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestReaderClosed.java
@@ -25,7 +25,6 @@ import org.apache.lucene.store.AlreadyClosedException;
import org.apache.lucene.store.Directory;
import org.apache.lucene.tests.analysis.MockAnalyzer;
import org.apache.lucene.tests.analysis.MockTokenizer;
-import org.apache.lucene.tests.index.OwnCacheKeyMultiReader;
import org.apache.lucene.tests.index.RandomIndexWriter;
import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.tests.util.TestUtil;
@@ -81,39 +80,6 @@ public class TestReaderClosed extends LuceneTestCase {
}
}
- // LUCENE-3800
- public void testReaderChaining() throws Exception {
- assertTrue(reader.getRefCount() > 0);
- LeafReader wrappedReader = new ParallelLeafReader(getOnlyLeafReader(reader));
-
- // We wrap with a OwnCacheKeyMultiReader so that closing the underlying reader
- // does not terminate the threadpool (if that index searcher uses one)
- IndexSearcher searcher = newSearcher(new OwnCacheKeyMultiReader(wrappedReader));
-
- TermRangeQuery query = TermRangeQuery.newStringRange("field", "a", "z", true, true);
- searcher.search(query, 5);
- reader.close(); // close original child reader
- try {
- searcher.search(query, 5);
- } catch (Exception e) {
- AlreadyClosedException ace = null;
- for (Throwable t = e; t != null; t = t.getCause()) {
- if (t instanceof AlreadyClosedException) {
- ace = (AlreadyClosedException) t;
- }
- }
- if (ace == null) {
- throw new AssertionError("Query failed, but not due to an AlreadyClosedException", e);
- }
- assertEquals(
- "this IndexReader cannot be used anymore as one of its child readers was closed",
- ace.getMessage());
- } finally {
- // close executor: in case of wrap-wrap-wrapping
- searcher.getIndexReader().close();
- }
- }
-
@Override
public void tearDown() throws Exception {
dir.close();