mirror of https://github.com/apache/lucene.git
Delete TimeLimitingCollector after deprecation (#13243)
Co-authored-by: Kaival Parikh <kaivalp2000@gmail.com>
This commit is contained in:
Kaival Parikh
GitHub
parent
ce978d7646
commit
d6eb126871
|
|
@ -192,6 +192,10 @@ enum.
|
|||
|
||||
`IOContext.READ` has been removed, it should be replaced with `IOContext.DEFAULT`.
|
||||
|
||||
### TimeLimitingCollector removed (GITHUB#13243)
|
||||
|
||||
`TimeLimitingCollector` has been removed, use `IndexSearcher#setTimeout(QueryTimeout)` to time out queries instead.
|
||||
|
||||
## Migration from Lucene 9.0 to Lucene 9.1
|
||||
|
||||
### Test framework package migration and module (LUCENE-10301)
|
||||
|
|
|
|||
|
|
@ -1,325 +0,0 @@
|
|||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The ASF licenses this file to You 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 org.apache.lucene.search;
|
||||
|
||||
import java.io.IOException;
|
||||
import org.apache.lucene.index.LeafReaderContext;
|
||||
import org.apache.lucene.index.QueryTimeout;
|
||||
import org.apache.lucene.util.Counter;
|
||||
import org.apache.lucene.util.SuppressForbidden;
|
||||
import org.apache.lucene.util.ThreadInterruptedException;
|
||||
|
||||
/**
|
||||
* The {@link TimeLimitingCollector} is used to timeout search requests that take longer than the
|
||||
* maximum allowed search time limit. After this time is exceeded, the search thread is stopped by
|
||||
* throwing a {@link TimeExceededException}.
|
||||
*
|
||||
* @deprecated Use {@link IndexSearcher#setTimeout(QueryTimeout)} to time out queries.
|
||||
* @see org.apache.lucene.index.ExitableDirectoryReader
|
||||
*/
|
||||
@Deprecated
|
||||
public class TimeLimitingCollector implements Collector {
|
||||
|
||||
/** Thrown when elapsed search time exceeds allowed search time. */
|
||||
@SuppressWarnings("serial")
|
||||
public static class TimeExceededException extends RuntimeException {
|
||||
private final long timeAllowed;
|
||||
private final long timeElapsed;
|
||||
private final int lastDocCollected;
|
||||
|
||||
private TimeExceededException(long timeAllowed, long timeElapsed, int lastDocCollected) {
|
||||
super(
|
||||
"Elapsed time: "
|
||||
+ timeElapsed
|
||||
+ ". Exceeded allowed search time: "
|
||||
+ timeAllowed
|
||||
+ " ms.");
|
||||
this.timeAllowed = timeAllowed;
|
||||
this.timeElapsed = timeElapsed;
|
||||
this.lastDocCollected = lastDocCollected;
|
||||
}
|
||||
|
||||
/** Returns allowed time (milliseconds). */
|
||||
public long getTimeAllowed() {
|
||||
return timeAllowed;
|
||||
}
|
||||
|
||||
/** Returns elapsed time (milliseconds). */
|
||||
public long getTimeElapsed() {
|
||||
return timeElapsed;
|
||||
}
|
||||
|
||||
/** Returns last doc (absolute doc id) that was collected when the search time exceeded. */
|
||||
public int getLastDocCollected() {
|
||||
return lastDocCollected;
|
||||
}
|
||||
}
|
||||
|
||||
private long t0 = Long.MIN_VALUE;
|
||||
private long timeout = Long.MIN_VALUE;
|
||||
private Collector collector;
|
||||
private final Counter clock;
|
||||
private final long ticksAllowed;
|
||||
private boolean greedy = false;
|
||||
private int docBase;
|
||||
|
||||
/**
|
||||
* Create a TimeLimitedCollector wrapper over another {@link Collector} with a specified timeout.
|
||||
*
|
||||
* @param collector the wrapped {@link Collector}
|
||||
* @param clock the timer clock
|
||||
* @param ticksAllowed max time allowed for collecting hits after which {@link
|
||||
* TimeExceededException} is thrown
|
||||
*/
|
||||
public TimeLimitingCollector(final Collector collector, Counter clock, final long ticksAllowed) {
|
||||
this.collector = collector;
|
||||
this.clock = clock;
|
||||
this.ticksAllowed = ticksAllowed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the baseline for this collector. By default the collectors baseline is initialized once
|
||||
* the first reader is passed to the collector. To include operations executed in prior to the
|
||||
* actual document collection set the baseline through this method in your prelude.
|
||||
*
|
||||
* <p>Example usage:
|
||||
*
|
||||
* <pre class="prettyprint">
|
||||
* Counter clock = ...;
|
||||
* long baseline = clock.get();
|
||||
* // ... prepare search
|
||||
* TimeLimitingCollector collector = new TimeLimitingCollector(c, clock, numTicks);
|
||||
* collector.setBaseline(baseline);
|
||||
* indexSearcher.search(query, collector);
|
||||
* </pre>
|
||||
*
|
||||
* @see #setBaseline()
|
||||
*/
|
||||
public void setBaseline(long clockTime) {
|
||||
t0 = clockTime;
|
||||
timeout = t0 + ticksAllowed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Syntactic sugar for {@link #setBaseline(long)} using {@link Counter#get()} on the clock passed
|
||||
* to the constructor.
|
||||
*/
|
||||
public void setBaseline() {
|
||||
setBaseline(clock.get());
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this time limited collector is greedy in collecting the last hit. A non greedy
|
||||
* collector, upon a timeout, would throw a {@link TimeExceededException} without allowing the
|
||||
* wrapped collector to collect current doc. A greedy one would first allow the wrapped hit
|
||||
* collector to collect current doc and only then throw a {@link TimeExceededException}. However,
|
||||
* if the timeout is detected in {@link #getLeafCollector} then no current document is collected.
|
||||
*
|
||||
* @see #setGreedy(boolean)
|
||||
*/
|
||||
public boolean isGreedy() {
|
||||
return greedy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets whether this time limited collector is greedy.
|
||||
*
|
||||
* @param greedy true to make this time limited greedy
|
||||
* @see #isGreedy()
|
||||
*/
|
||||
public void setGreedy(boolean greedy) {
|
||||
this.greedy = greedy;
|
||||
}
|
||||
|
||||
@Override
|
||||
public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
|
||||
this.docBase = context.docBase;
|
||||
if (Long.MIN_VALUE == t0) {
|
||||
setBaseline();
|
||||
}
|
||||
final long time = clock.get();
|
||||
if (time - timeout > 0L) {
|
||||
throw new TimeExceededException(timeout - t0, time - t0, -1);
|
||||
}
|
||||
return new FilterLeafCollector(collector.getLeafCollector(context)) {
|
||||
|
||||
@Override
|
||||
public void collect(int doc) throws IOException {
|
||||
final long time = clock.get();
|
||||
if (time - timeout > 0L) {
|
||||
if (greedy) {
|
||||
// System.out.println(this+" greedy: before failing, collecting doc: "+(docBase +
|
||||
// doc)+" "+(time-t0));
|
||||
in.collect(doc);
|
||||
}
|
||||
// System.out.println(this+" failing on: "+(docBase + doc)+" "+(time-t0));
|
||||
throw new TimeExceededException(timeout - t0, time - t0, docBase + doc);
|
||||
}
|
||||
// System.out.println(this+" collecting: "+(docBase + doc)+" "+(time-t0));
|
||||
in.collect(doc);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public ScoreMode scoreMode() {
|
||||
return collector.scoreMode();
|
||||
}
|
||||
|
||||
/**
|
||||
* This is so the same timer can be used with a multi-phase search process such as grouping. We
|
||||
* don't want to create a new TimeLimitingCollector for each phase because that would reset the
|
||||
* timer for each phase. Once time is up subsequent phases need to timeout quickly.
|
||||
*
|
||||
* @param collector The actual collector performing search functionality
|
||||
*/
|
||||
public void setCollector(Collector collector) {
|
||||
this.collector = collector;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the global TimerThreads {@link Counter}
|
||||
*
|
||||
* <p>Invoking this creates may create a new instance of {@link TimerThread} iff the global {@link
|
||||
* TimerThread} has never been accessed before. The thread returned from this method is started on
|
||||
* creation and will be alive unless you stop the {@link TimerThread} via {@link
|
||||
* TimerThread#stopTimer()}.
|
||||
*
|
||||
* @return the global TimerThreads {@link Counter}
|
||||
* @lucene.experimental
|
||||
*/
|
||||
public static Counter getGlobalCounter() {
|
||||
return TimerThreadHolder.THREAD.counter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the global {@link TimerThread}.
|
||||
*
|
||||
* <p>Invoking this creates may create a new instance of {@link TimerThread} iff the global {@link
|
||||
* TimerThread} has never been accessed before. The thread returned from this method is started on
|
||||
* creation and will be alive unless you stop the {@link TimerThread} via {@link
|
||||
* TimerThread#stopTimer()}.
|
||||
*
|
||||
* @return the global {@link TimerThread}
|
||||
* @lucene.experimental
|
||||
*/
|
||||
public static TimerThread getGlobalTimerThread() {
|
||||
return TimerThreadHolder.THREAD;
|
||||
}
|
||||
|
||||
private static final class TimerThreadHolder {
|
||||
static final TimerThread THREAD;
|
||||
|
||||
static {
|
||||
THREAD = new TimerThread(Counter.newCounter(true));
|
||||
THREAD.start();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Thread used to timeout search requests. Can be stopped completely with {@link
|
||||
* TimerThread#stopTimer()}
|
||||
*
|
||||
* @lucene.experimental
|
||||
*/
|
||||
public static final class TimerThread extends Thread {
|
||||
|
||||
public static final String THREAD_NAME = "TimeLimitedCollector timer thread";
|
||||
public static final int DEFAULT_RESOLUTION = 20;
|
||||
// NOTE: we can avoid explicit synchronization here for several reasons:
|
||||
// * updates to volatile long variables are atomic
|
||||
// * only single thread modifies this value
|
||||
// * use of volatile keyword ensures that it does not reside in
|
||||
// a register, but in main memory (so that changes are visible to
|
||||
// other threads).
|
||||
// * visibility of changes does not need to be instantaneous, we can
|
||||
// afford losing a tick or two.
|
||||
//
|
||||
// See section 17 of the Java Language Specification for details.
|
||||
private volatile long time = 0;
|
||||
private volatile boolean stop = false;
|
||||
private volatile long resolution;
|
||||
final Counter counter;
|
||||
|
||||
public TimerThread(long resolution, Counter counter) {
|
||||
super(THREAD_NAME);
|
||||
this.resolution = resolution;
|
||||
this.counter = counter;
|
||||
this.setDaemon(true);
|
||||
}
|
||||
|
||||
public TimerThread(Counter counter) {
|
||||
this(DEFAULT_RESOLUTION, counter);
|
||||
}
|
||||
|
||||
@SuppressForbidden(reason = "Thread sleep")
|
||||
@Override
|
||||
public void run() {
|
||||
while (!stop) {
|
||||
// TODO: Use System.nanoTime() when Lucene moves to Java SE 5.
|
||||
counter.addAndGet(resolution);
|
||||
try {
|
||||
Thread.sleep(resolution);
|
||||
} catch (InterruptedException ie) {
|
||||
throw new ThreadInterruptedException(ie);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Get the timer value in milliseconds. */
|
||||
public long getMilliseconds() {
|
||||
return time;
|
||||
}
|
||||
|
||||
/** Stops the timer thread */
|
||||
public void stopTimer() {
|
||||
stop = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the timer resolution.
|
||||
*
|
||||
* @see #setResolution(long)
|
||||
*/
|
||||
public long getResolution() {
|
||||
return resolution;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the timer resolution. The default timer resolution is 20 milliseconds. This means that a
|
||||
* search required to take no longer than 800 milliseconds may be stopped after 780 to 820
|
||||
* milliseconds. <br>
|
||||
* Note that:
|
||||
*
|
||||
* <ul>
|
||||
* <li>Finer (smaller) resolution is more accurate but less efficient.
|
||||
* <li>Setting resolution to less than 5 milliseconds will be silently modified to 5
|
||||
* milliseconds.
|
||||
* <li>Setting resolution smaller than current resolution might take effect only after current
|
||||
* resolution. (Assume current resolution of 20 milliseconds is modified to 5
|
||||
* milliseconds, then it can take up to 20 milliseconds for the change to have effect.
|
||||
* </ul>
|
||||
*/
|
||||
public void setResolution(long resolution) {
|
||||
this.resolution =
|
||||
Math.max(
|
||||
resolution,
|
||||
5); // 5 milliseconds is about the minimum reasonable time for a Object.wait(long)
|
||||
// call.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,407 +0,0 @@
|
|||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The ASF licenses this file to You 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 org.apache.lucene.search;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.BitSet;
|
||||
import org.apache.lucene.document.Document;
|
||||
import org.apache.lucene.document.Field;
|
||||
import org.apache.lucene.index.IndexReader;
|
||||
import org.apache.lucene.index.LeafReaderContext;
|
||||
import org.apache.lucene.index.Term;
|
||||
import org.apache.lucene.search.TimeLimitingCollector.TimeExceededException;
|
||||
import org.apache.lucene.search.TimeLimitingCollector.TimerThread;
|
||||
import org.apache.lucene.store.Directory;
|
||||
import org.apache.lucene.tests.analysis.MockAnalyzer;
|
||||
import org.apache.lucene.tests.index.RandomIndexWriter;
|
||||
import org.apache.lucene.tests.util.LuceneTestCase;
|
||||
import org.apache.lucene.tests.util.LuceneTestCase.SuppressSysoutChecks;
|
||||
import org.apache.lucene.tests.util.TestUtil;
|
||||
import org.apache.lucene.util.Counter;
|
||||
import org.apache.lucene.util.SuppressForbidden;
|
||||
import org.apache.lucene.util.ThreadInterruptedException;
|
||||
|
||||
/**
|
||||
* Tests the {@link TimeLimitingCollector}. This test checks (1) search correctness (regardless of
|
||||
* timeout), (2) expected timeout behavior, and (3) a sanity test with multiple searching threads.
|
||||
*/
|
||||
@SuppressSysoutChecks(bugUrl = "http://test.is.timing.sensitive.so.it.prints.instead.of.failing")
|
||||
public class TestTimeLimitingCollector extends LuceneTestCase {
|
||||
private static final int SLOW_DOWN = 3;
|
||||
private static final long TIME_ALLOWED = 17 * SLOW_DOWN; // so searches can find about 17 docs.
|
||||
|
||||
// max time allowed is relaxed for multithreading tests.
|
||||
// the multithread case fails when setting this to 1 (no slack) and launching many threads
|
||||
// (>2000).
|
||||
// but this is not a real failure, just noise.
|
||||
private static final double MULTI_THREAD_SLACK = 7;
|
||||
|
||||
private static final int N_DOCS = 3000;
|
||||
private static final int N_THREADS = 50;
|
||||
|
||||
private IndexSearcher searcher;
|
||||
private Directory directory;
|
||||
private IndexReader reader;
|
||||
|
||||
private final String FIELD_NAME = "body";
|
||||
private Query query;
|
||||
private Counter counter;
|
||||
private TimerThread counterThread;
|
||||
|
||||
/** initializes searcher with a document set */
|
||||
@Override
|
||||
public void setUp() throws Exception {
|
||||
super.setUp();
|
||||
counter = Counter.newCounter(true);
|
||||
counterThread = new TimerThread(counter);
|
||||
counterThread.start();
|
||||
final String[] docText = {
|
||||
"docThatNeverMatchesSoWeCanRequireLastDocCollectedToBeGreaterThanZero",
|
||||
"one blah three",
|
||||
"one foo three multiOne",
|
||||
"one foobar three multiThree",
|
||||
"blueberry pancakes",
|
||||
"blueberry pie",
|
||||
"blueberry strudel",
|
||||
"blueberry pizza",
|
||||
};
|
||||
directory = newDirectory();
|
||||
RandomIndexWriter iw =
|
||||
new RandomIndexWriter(
|
||||
random(),
|
||||
directory,
|
||||
newIndexWriterConfig(new MockAnalyzer(random())).setMergePolicy(newLogMergePolicy()));
|
||||
|
||||
for (int i = 0; i < N_DOCS; i++) {
|
||||
add(docText[i % docText.length], iw);
|
||||
}
|
||||
reader = iw.getReader();
|
||||
iw.close();
|
||||
searcher = newSearcher(reader);
|
||||
|
||||
BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
|
||||
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "one")), BooleanClause.Occur.SHOULD);
|
||||
// start from 1, so that the 0th doc never matches
|
||||
for (int i = 1; i < docText.length; i++) {
|
||||
String[] docTextParts = docText[i].split("\\s+");
|
||||
for (String docTextPart : docTextParts) { // large query so that search will be longer
|
||||
booleanQuery.add(
|
||||
new TermQuery(new Term(FIELD_NAME, docTextPart)), BooleanClause.Occur.SHOULD);
|
||||
}
|
||||
}
|
||||
|
||||
query = booleanQuery.build();
|
||||
|
||||
// warm the searcher
|
||||
searcher.search(query, 1000);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tearDown() throws Exception {
|
||||
reader.close();
|
||||
directory.close();
|
||||
counterThread.stopTimer();
|
||||
counterThread.join();
|
||||
super.tearDown();
|
||||
}
|
||||
|
||||
private void add(String value, RandomIndexWriter iw) throws IOException {
|
||||
Document d = new Document();
|
||||
d.add(newTextField(FIELD_NAME, value, Field.Store.NO));
|
||||
iw.addDocument(d);
|
||||
}
|
||||
|
||||
private void search(Collector collector) throws Exception {
|
||||
searcher.search(query, collector);
|
||||
}
|
||||
|
||||
/** test search correctness with no timeout */
|
||||
public void testSearch() {
|
||||
doTestSearch();
|
||||
}
|
||||
|
||||
private void doTestSearch() {
|
||||
int totalResults = 0;
|
||||
int totalTLCResults = 0;
|
||||
try {
|
||||
MyHitCollector myHc = new MyHitCollector();
|
||||
search(myHc);
|
||||
totalResults = myHc.hitCount();
|
||||
|
||||
myHc = new MyHitCollector();
|
||||
long oneHour = 3600000;
|
||||
long duration = TestUtil.nextLong(random(), oneHour, Long.MAX_VALUE);
|
||||
Collector tlCollector = createTimedCollector(myHc, duration, false);
|
||||
search(tlCollector);
|
||||
totalTLCResults = myHc.hitCount();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
assertTrue("Unexpected exception: " + e, false); // ==fail
|
||||
}
|
||||
assertEquals("Wrong number of results!", totalResults, totalTLCResults);
|
||||
}
|
||||
|
||||
private Collector createTimedCollector(MyHitCollector hc, long timeAllowed, boolean greedy) {
|
||||
TimeLimitingCollector res = new TimeLimitingCollector(hc, counter, timeAllowed);
|
||||
res.setGreedy(greedy); // set to true to make sure at least one doc is collected.
|
||||
return res;
|
||||
}
|
||||
|
||||
/** Test that timeout is obtained, and soon enough! */
|
||||
public void testTimeoutGreedy() {
|
||||
doTestTimeout(false, true);
|
||||
}
|
||||
|
||||
/** Test that timeout is obtained, and soon enough! */
|
||||
public void testTimeoutNotGreedy() {
|
||||
doTestTimeout(false, false);
|
||||
}
|
||||
|
||||
private void doTestTimeout(boolean multiThreaded, boolean greedy) {
|
||||
// setup
|
||||
MyHitCollector myHc = new MyHitCollector();
|
||||
myHc.setSlowDown(SLOW_DOWN);
|
||||
Collector tlCollector = createTimedCollector(myHc, TIME_ALLOWED, greedy);
|
||||
|
||||
// search: must get exception
|
||||
TimeExceededException timeoutException =
|
||||
expectThrows(
|
||||
TimeExceededException.class,
|
||||
() -> {
|
||||
search(tlCollector);
|
||||
});
|
||||
|
||||
// greediness affect last doc collected
|
||||
int exceptionDoc = timeoutException.getLastDocCollected();
|
||||
int lastCollected = myHc.getLastDocCollected();
|
||||
|
||||
// exceptionDoc == -1 means we hit the timeout in getLeafCollector:
|
||||
if (exceptionDoc != -1) {
|
||||
assertTrue(
|
||||
"doc collected at timeout must be > 0! or == -1 but was: " + exceptionDoc,
|
||||
exceptionDoc > 0);
|
||||
if (greedy) {
|
||||
assertTrue(
|
||||
"greedy="
|
||||
+ greedy
|
||||
+ " exceptionDoc="
|
||||
+ exceptionDoc
|
||||
+ " != lastCollected="
|
||||
+ lastCollected,
|
||||
exceptionDoc == lastCollected);
|
||||
assertTrue("greedy, but no hits found!", myHc.hitCount() > 0);
|
||||
} else {
|
||||
assertTrue(
|
||||
"greedy="
|
||||
+ greedy
|
||||
+ " exceptionDoc="
|
||||
+ exceptionDoc
|
||||
+ " not > lastCollected="
|
||||
+ lastCollected,
|
||||
exceptionDoc > lastCollected);
|
||||
}
|
||||
}
|
||||
|
||||
// verify that elapsed time at exception is within valid limits
|
||||
assertEquals(timeoutException.getTimeAllowed(), TIME_ALLOWED);
|
||||
// a) Not too early
|
||||
assertTrue(
|
||||
"elapsed="
|
||||
+ timeoutException.getTimeElapsed()
|
||||
+ " <= (allowed-resolution)="
|
||||
+ (TIME_ALLOWED - counterThread.getResolution()),
|
||||
timeoutException.getTimeElapsed() > TIME_ALLOWED - counterThread.getResolution());
|
||||
// b) Not too late.
|
||||
// This part is problematic in a busy test system, so we just print a warning.
|
||||
// We already verified that a timeout occurred, we just can't be picky about how long it
|
||||
// took.
|
||||
if (timeoutException.getTimeElapsed() > maxTime(multiThreaded)) {
|
||||
System.out.println(
|
||||
"Informative: timeout exceeded (no action required: most probably just "
|
||||
+ " because the test machine is slower than usual): "
|
||||
+ "lastDoc="
|
||||
+ exceptionDoc
|
||||
+ " ,&& allowed="
|
||||
+ timeoutException.getTimeAllowed()
|
||||
+ " ,&& elapsed="
|
||||
+ timeoutException.getTimeElapsed()
|
||||
+ " >= "
|
||||
+ maxTimeStr(multiThreaded));
|
||||
}
|
||||
}
|
||||
|
||||
private long maxTime(boolean multiThreaded) {
|
||||
long res =
|
||||
2 * counterThread.getResolution()
|
||||
+ TIME_ALLOWED
|
||||
+ SLOW_DOWN; // some slack for less noise in this test
|
||||
if (multiThreaded) {
|
||||
res *= MULTI_THREAD_SLACK; // larger slack
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
private String maxTimeStr(boolean multiThreaded) {
|
||||
String s =
|
||||
"( "
|
||||
+ "2*resolution + TIME_ALLOWED + SLOW_DOWN = "
|
||||
+ "2*"
|
||||
+ counterThread.getResolution()
|
||||
+ " + "
|
||||
+ TIME_ALLOWED
|
||||
+ " + "
|
||||
+ SLOW_DOWN
|
||||
+ ")";
|
||||
if (multiThreaded) {
|
||||
s = MULTI_THREAD_SLACK + " * " + s;
|
||||
}
|
||||
return maxTime(multiThreaded) + " = " + s;
|
||||
}
|
||||
|
||||
/** Test timeout behavior when resolution is modified. */
|
||||
public void testModifyResolution() {
|
||||
try {
|
||||
// increase and test
|
||||
long resolution = 20 * TimerThread.DEFAULT_RESOLUTION; // 400
|
||||
counterThread.setResolution(resolution);
|
||||
assertEquals(resolution, counterThread.getResolution());
|
||||
doTestTimeout(false, true);
|
||||
// decrease much and test
|
||||
resolution = 5;
|
||||
counterThread.setResolution(resolution);
|
||||
assertEquals(resolution, counterThread.getResolution());
|
||||
doTestTimeout(false, true);
|
||||
// return to default and test
|
||||
resolution = TimerThread.DEFAULT_RESOLUTION;
|
||||
counterThread.setResolution(resolution);
|
||||
assertEquals(resolution, counterThread.getResolution());
|
||||
doTestTimeout(false, true);
|
||||
} finally {
|
||||
counterThread.setResolution(TimerThread.DEFAULT_RESOLUTION);
|
||||
}
|
||||
}
|
||||
|
||||
public void testNoHits() throws IOException {
|
||||
MyHitCollector myHc = new MyHitCollector();
|
||||
Collector collector = createTimedCollector(myHc, -1, random().nextBoolean());
|
||||
// search: must get exception
|
||||
expectThrows(
|
||||
TimeExceededException.class,
|
||||
() -> {
|
||||
BooleanQuery.Builder booleanQuery =
|
||||
new BooleanQuery
|
||||
.Builder(); // won't match - we only test if we check timeout when collectors are
|
||||
// pulled
|
||||
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "one")), BooleanClause.Occur.MUST);
|
||||
booleanQuery.add(
|
||||
new TermQuery(new Term(FIELD_NAME, "blueberry")), BooleanClause.Occur.MUST);
|
||||
searcher.search(booleanQuery.build(), collector);
|
||||
});
|
||||
assertEquals(-1, myHc.getLastDocCollected());
|
||||
}
|
||||
|
||||
/** Test correctness with multiple searching threads. */
|
||||
public void testSearchMultiThreaded() throws Exception {
|
||||
doTestMultiThreads(false);
|
||||
}
|
||||
|
||||
/** Test correctness with multiple searching threads. */
|
||||
public void testTimeoutMultiThreaded() throws Exception {
|
||||
doTestMultiThreads(true);
|
||||
}
|
||||
|
||||
private void doTestMultiThreads(final boolean withTimeout) throws Exception {
|
||||
Thread[] threadArray = new Thread[N_THREADS];
|
||||
final BitSet success = new BitSet(N_THREADS);
|
||||
for (int i = 0; i < threadArray.length; ++i) {
|
||||
final int num = i;
|
||||
threadArray[num] =
|
||||
new Thread() {
|
||||
@Override
|
||||
public void run() {
|
||||
if (withTimeout) {
|
||||
doTestTimeout(true, true);
|
||||
} else {
|
||||
doTestSearch();
|
||||
}
|
||||
synchronized (success) {
|
||||
success.set(num);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
for (int i = 0; i < threadArray.length; ++i) {
|
||||
threadArray[i].start();
|
||||
}
|
||||
for (int i = 0; i < threadArray.length; ++i) {
|
||||
threadArray[i].join();
|
||||
}
|
||||
assertEquals("some threads failed!", N_THREADS, success.cardinality());
|
||||
}
|
||||
|
||||
// counting collector that can slow down at collect().
|
||||
private static class MyHitCollector extends SimpleCollector {
|
||||
private final BitSet bits = new BitSet();
|
||||
private int slowdown = 0;
|
||||
private int lastDocCollected = -1;
|
||||
private int docBase = 0;
|
||||
|
||||
/** amount of time to wait on each collect to simulate a long iteration */
|
||||
public void setSlowDown(int milliseconds) {
|
||||
slowdown = milliseconds;
|
||||
}
|
||||
|
||||
public int hitCount() {
|
||||
return bits.cardinality();
|
||||
}
|
||||
|
||||
public int getLastDocCollected() {
|
||||
return lastDocCollected;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setScorer(Scorable scorer) throws IOException {
|
||||
// scorer is not needed
|
||||
}
|
||||
|
||||
@SuppressForbidden(reason = "Thread sleep")
|
||||
@Override
|
||||
public void collect(final int doc) throws IOException {
|
||||
int docId = doc + docBase;
|
||||
if (slowdown > 0) {
|
||||
try {
|
||||
Thread.sleep(slowdown);
|
||||
} catch (InterruptedException ie) {
|
||||
throw new ThreadInterruptedException(ie);
|
||||
}
|
||||
}
|
||||
assert docId >= 0 : " base=" + docBase + " doc=" + doc;
|
||||
bits.set(docId);
|
||||
lastDocCollected = docId;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void doSetNextReader(LeafReaderContext context) throws IOException {
|
||||
docBase = context.docBase;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ScoreMode scoreMode() {
|
||||
return ScoreMode.COMPLETE;
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue