You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@solr.apache.org by is...@apache.org on 2024/05/13 15:43:54 UTC
(solr) branch jira/solr-13350-9x-2 updated: Multithreaded search
This is an automated email from the ASF dual-hosted git repository.
ishan pushed a commit to branch jira/solr-13350-9x-2
in repository https://gitbox.apache.org/repos/asf/solr.git
The following commit(s) were added to refs/heads/jira/solr-13350-9x-2 by this push:
new fc8762930f4 Multithreaded search
fc8762930f4 is described below
commit fc8762930f4b22c0ce07d6b6726e5e8069d827ff
Author: Ishan Chattopadhyaya <is...@apache.org>
AuthorDate: Mon May 13 21:13:43 2024 +0530
Multithreaded search
---
solr/CHANGES.txt | 2 +-
solr/bin/solr | 3 +
.../java/org/apache/solr/core/CoreContainer.java | 15 +
.../src/java/org/apache/solr/core/NodeConfig.java | 17 +
.../java/org/apache/solr/core/SolrXmlConfig.java | 3 +
.../solr/handler/component/QueryComponent.java | 3 +
.../apache/solr/search/MultiThreadedSearcher.java | 423 +++++++++++++++++++++
.../java/org/apache/solr/search/QueryCommand.java | 10 +
.../org/apache/solr/search/SolrIndexSearcher.java | 134 +++++--
.../solr/search/SolrMultiCollectorManager.java | 155 ++++++++
solr/core/src/test-files/solr/solr-50-all.xml | 1 +
solr/core/src/test-files/solr/solr-stress-new.xml | 1 +
.../test-files/solr/solr-trackingshardhandler.xml | 1 +
solr/core/src/test-files/solr/solr.xml | 1 +
.../apache/solr/search/TestCpuAllowedLimit.java | 8 +-
.../test/org/apache/solr/search/TestFiltering.java | 18 +-
.../org/apache/solr/search/TestQueryLimits.java | 12 +-
solr/server/solr/solr.xml | 1 +
.../pages/configuring-solr-xml.adoc | 9 +
19 files changed, 771 insertions(+), 46 deletions(-)
diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt
index 123ba153134..4ba25916b10 100644
--- a/solr/CHANGES.txt
+++ b/solr/CHANGES.txt
@@ -7,7 +7,7 @@ https://github.com/apache/solr/blob/main/solr/solr-ref-guide/modules/upgrade-not
================== 9.7.0 ==================
New Features
---------------------
-(No changes)
+* SOLR-13350: Multithreaded search execution (Ishan Chattopadhyaya, Mark Miller, Christine Poerschke, David Smiley, noble)
* SOLR-17192: Put an UpdateRequestProcessor-enforced soft-limit on the number of fields allowed in a core. The `NumFieldLimitingUpdateRequestProcessorFactory`
limit may be adjusted by raising the factory's `maxFields` setting, toggled in and out of "warning-only" mode using the `warnOnly` setting, or disabled entirely
diff --git a/solr/bin/solr b/solr/bin/solr
index 698d996c0df..93c6741c346 100755
--- a/solr/bin/solr
+++ b/solr/bin/solr
@@ -1917,6 +1917,9 @@ if [ $# -gt 0 ]; then
done
fi
+# Setting number of threads for search
+if ! command -v nproc &> /dev/null; then echo "Couldn't determine number of CPUs, using default number of search threads"; else cpus=`nproc`; SCRIPT_SOLR_OPTS+="-Dsolr.searchThreads=$cpus"; fi
+
# Default placement plugin
if [[ -n "${SOLR_PLACEMENTPLUGIN_DEFAULT:-}" ]] ; then
SCRIPT_SOLR_OPTS+=("-Dsolr.placementplugin.default=$SOLR_PLACEMENTPLUGIN_DEFAULT")
diff --git a/solr/core/src/java/org/apache/solr/core/CoreContainer.java b/solr/core/src/java/org/apache/solr/core/CoreContainer.java
index 0c88c2eaa95..452a6a086fb 100644
--- a/solr/core/src/java/org/apache/solr/core/CoreContainer.java
+++ b/solr/core/src/java/org/apache/solr/core/CoreContainer.java
@@ -51,6 +51,7 @@ import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeoutException;
import java.util.function.Function;
@@ -177,6 +178,10 @@ public class CoreContainer {
final SolrCores solrCores;
+ public Executor getCollectorExecutor() {
+ return collectorExecutor;
+ }
+
public static class CoreLoadFailure {
public final CoreDescriptor cd;
@@ -280,6 +285,8 @@ public class CoreContainer {
public final NodeRoles nodeRoles = new NodeRoles(System.getProperty(NodeRoles.NODE_ROLES_PROP));
+ private final ExecutorService collectorExecutor;
+
private final ClusterSingletons clusterSingletons =
new ClusterSingletons(
() ->
@@ -434,6 +441,12 @@ public class CoreContainer {
this.allowPaths = allowPathBuilder.build();
this.allowListUrlChecker = AllowListUrlChecker.create(config);
+
+ this.collectorExecutor =
+ ExecutorUtil.newMDCAwareCachedThreadPool(
+ cfg.getIndexSearcherExecutorThreads(), // thread count
+ cfg.getIndexSearcherExecutorThreads() * 1000, // queue size
+ new SolrNamedThreadFactory("searcherCollector"));
}
@SuppressWarnings({"unchecked"})
@@ -659,6 +672,7 @@ public class CoreContainer {
distributedCollectionCommandRunner = Optional.empty();
allowPaths = null;
allowListUrlChecker = null;
+ collectorExecutor = null;
}
public static CoreContainer createAndLoad(Path solrHome) {
@@ -1250,6 +1264,7 @@ public class CoreContainer {
}
ExecutorUtil.shutdownAndAwaitTermination(coreContainerAsyncTaskExecutor);
+ ExecutorUtil.shutdownAndAwaitTermination(collectorExecutor);
ExecutorService customThreadPool =
ExecutorUtil.newMDCAwareCachedThreadPool(new SolrNamedThreadFactory("closeThreadPool"));
diff --git a/solr/core/src/java/org/apache/solr/core/NodeConfig.java b/solr/core/src/java/org/apache/solr/core/NodeConfig.java
index 5bac7ff40a0..f9631f619b4 100644
--- a/solr/core/src/java/org/apache/solr/core/NodeConfig.java
+++ b/solr/core/src/java/org/apache/solr/core/NodeConfig.java
@@ -106,6 +106,8 @@ public class NodeConfig {
private final int replayUpdatesThreads;
+ private final int indexSearcherExecutorThreads;
+
@Deprecated private final int transientCacheSize;
private final boolean useSchemaCache;
@@ -149,6 +151,7 @@ public class NodeConfig {
CloudConfig cloudConfig,
Integer coreLoadThreads,
int replayUpdatesThreads,
+ int indexSearcherExecutorThreads,
int transientCacheSize,
boolean useSchemaCache,
String managementPath,
@@ -189,6 +192,7 @@ public class NodeConfig {
this.cloudConfig = cloudConfig;
this.coreLoadThreads = coreLoadThreads;
this.replayUpdatesThreads = replayUpdatesThreads;
+ this.indexSearcherExecutorThreads = indexSearcherExecutorThreads;
this.transientCacheSize = transientCacheSize;
this.useSchemaCache = useSchemaCache;
this.managementPath = managementPath;
@@ -350,6 +354,10 @@ public class NodeConfig {
return replayUpdatesThreads;
}
+ public int getIndexSearcherExecutorThreads() {
+ return indexSearcherExecutorThreads;
+ }
+
/**
* Returns a directory, optionally a comma separated list of directories that will be added to
* Solr's class path for searching for classes and plugins. The path is either absolute or
@@ -648,6 +656,7 @@ public class NodeConfig {
private CloudConfig cloudConfig;
private int coreLoadThreads = DEFAULT_CORE_LOAD_THREADS;
private int replayUpdatesThreads = Runtime.getRuntime().availableProcessors();
+ private int indexSearcherExecutorThreads = DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS;
@Deprecated private int transientCacheSize = -1;
private boolean useSchemaCache = false;
private String managementPath;
@@ -670,6 +679,8 @@ public class NodeConfig {
// No:of core load threads in cloud mode is set to a default of 8
public static final int DEFAULT_CORE_LOAD_THREADS_IN_CLOUD = 8;
+ public static final int DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS = 4;
+
private static final String DEFAULT_CORESLOCATORCLASS =
"org.apache.solr.core.CorePropertiesLocator";
private static final String DEFAULT_CORESORTERCLASS = "org.apache.solr.core.CoreSorter";
@@ -807,6 +818,11 @@ public class NodeConfig {
return this;
}
+ public NodeConfigBuilder setIndexSearcherExecutorThreads(int indexSearcherExecutorThreads) {
+ this.indexSearcherExecutorThreads = indexSearcherExecutorThreads;
+ return this;
+ }
+
// Remove in Solr 10.0
@Deprecated
@@ -961,6 +977,7 @@ public class NodeConfig {
cloudConfig,
coreLoadThreads,
replayUpdatesThreads,
+ indexSearcherExecutorThreads,
transientCacheSize,
useSchemaCache,
managementPath,
diff --git a/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java b/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java
index 078eb018aa6..cb326e734ea 100644
--- a/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java
+++ b/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java
@@ -397,6 +397,9 @@ public class SolrXmlConfig {
case "replayUpdatesThreads":
builder.setReplayUpdatesThreads(it.intVal(-1));
break;
+ case "indexSearcherExecutorThreads":
+ builder.setIndexSearcherExecutorThreads(it.intVal(-1));
+ break;
case "transientCacheSize":
log.warn("solr.xml transientCacheSize -- transient cores is deprecated");
builder.setTransientCacheSize(it.intVal(-1));
diff --git a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
index 4f17cb7652b..4bc2a867ab2 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
@@ -372,10 +372,13 @@ public class QueryComponent extends SearchComponent {
return;
}
+ final boolean multiThreaded = params.getBool("multiThreaded", true);
+
// -1 as flag if not set.
long timeAllowed = params.getLong(CommonParams.TIME_ALLOWED, -1L);
QueryCommand cmd = rb.createQueryCommand();
+ cmd.setMultiThreaded(multiThreaded);
cmd.setTimeAllowed(timeAllowed);
cmd.setMinExactCount(getMinExactCount(params));
cmd.setDistribStatsDisabled(rb.isDistribStatsDisabled());
diff --git a/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java b/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java
new file mode 100644
index 00000000000..f9810b1a083
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java
@@ -0,0 +1,423 @@
+/*
+ * 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.solr.search;
+
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Supplier;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.Collector;
+import org.apache.lucene.search.CollectorManager;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.SimpleCollector;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.search.TopDocsCollector;
+import org.apache.lucene.search.TopFieldDocs;
+import org.apache.lucene.util.FixedBitSet;
+import org.apache.lucene.util.automaton.ByteRunAutomaton;
+import org.apache.solr.search.join.GraphQuery;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MultiThreadedSearcher {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ final SolrIndexSearcher searcher;
+
+ public MultiThreadedSearcher(SolrIndexSearcher searcher) {
+ this.searcher = searcher;
+ }
+
+ SearchResult searchCollectorManagers(
+ int len,
+ QueryCommand cmd,
+ Query query,
+ boolean needTopDocs,
+ boolean needMaxScore,
+ boolean needDocSet)
+ throws IOException {
+ Collection<CollectorManager<Collector, Object>> collectors = new ArrayList<>();
+
+ int firstCollectorsSize = 0;
+
+ final int firstTopDocsCollectorIndex;
+ if (needTopDocs) {
+ firstTopDocsCollectorIndex = firstCollectorsSize;
+ firstCollectorsSize++;
+ } else {
+ firstTopDocsCollectorIndex = -1;
+ }
+
+ final int firstMaxScoreCollectorIndex;
+ if (needMaxScore) {
+ firstMaxScoreCollectorIndex = firstCollectorsSize;
+ firstCollectorsSize++;
+ } else {
+ firstMaxScoreCollectorIndex = -1;
+ }
+
+ Collector[] firstCollectors = new Collector[firstCollectorsSize];
+
+ if (needTopDocs) {
+
+ collectors.add(new TopDocsCM(len, cmd, firstCollectors, firstTopDocsCollectorIndex));
+ }
+ if (needMaxScore) {
+ collectors.add(new MaxScoreCM(firstCollectors, firstMaxScoreCollectorIndex));
+ }
+ if (needDocSet) {
+ int maxDoc = searcher.getRawReader().maxDoc();
+ log.error("raw read max={}", searcher.getRawReader().maxDoc());
+
+ collectors.add(new DocSetCM(maxDoc));
+ }
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ CollectorManager<Collector, Object>[] colls = collectors.toArray(new CollectorManager[0]);
+ SolrMultiCollectorManager manager = new SolrMultiCollectorManager(colls);
+ Object[] ret;
+ try {
+ ret = searcher.search(query, manager);
+ } catch (Exception ex) {
+ if (ex instanceof RuntimeException
+ && ex.getCause() != null
+ && ex.getCause() instanceof ExecutionException
+ && ex.getCause().getCause() != null
+ && ex.getCause().getCause() instanceof RuntimeException) {
+ throw (RuntimeException) ex.getCause().getCause();
+ } else {
+ throw ex;
+ }
+ }
+
+ ScoreMode scoreMode = SolrMultiCollectorManager.scoreMode(firstCollectors);
+
+ return new SearchResult(scoreMode, ret);
+ }
+
+ static boolean allowMT(DelegatingCollector postFilter, QueryCommand cmd, Query query) {
+ if (postFilter != null
+ || cmd.getSegmentTerminateEarly()
+ || cmd.getTimeAllowed() > 0
+ || !cmd.getMultiThreaded()) {
+ return false;
+ } else {
+ MTCollectorQueryCheck allowMT = new MTCollectorQueryCheck();
+ query.visit(allowMT);
+ return allowMT.allowed();
+ }
+ }
+
+ /**
+ * A {@link QueryVisitor} that recurses through the query tree, determining if all queries support
+ * multi-threaded collecting.
+ */
+ private static class MTCollectorQueryCheck extends QueryVisitor {
+
+ private QueryVisitor subVisitor = this;
+
+ private boolean allowMt(Query query) {
+ if (query instanceof RankQuery || query instanceof GraphQuery || query instanceof JoinQuery) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public void consumeTerms(Query query, Term... terms) {
+ if (!allowMt(query)) {
+ subVisitor = EMPTY_VISITOR;
+ }
+ }
+
+ @Override
+ public void consumeTermsMatching(
+ Query query, String field, Supplier<ByteRunAutomaton> automaton) {
+ if (!allowMt(query)) {
+ subVisitor = EMPTY_VISITOR;
+ } else {
+ super.consumeTermsMatching(query, field, automaton);
+ }
+ }
+
+ @Override
+ public void visitLeaf(Query query) {
+ if (!allowMt(query)) {
+ subVisitor = EMPTY_VISITOR;
+ }
+ }
+
+ @Override
+ public QueryVisitor getSubVisitor(BooleanClause.Occur occur, Query parent) {
+ return subVisitor;
+ }
+
+ public boolean allowed() {
+ return subVisitor != EMPTY_VISITOR;
+ }
+ }
+
+ static class MaxScoreResult {
+ final float maxScore;
+
+ public MaxScoreResult(float maxScore) {
+ this.maxScore = maxScore;
+ }
+ }
+
+ static class FixedBitSetCollector extends SimpleCollector {
+ @SuppressWarnings("JdkObsolete")
+ private final LinkedList<FixedBitSet> bitSets = new LinkedList<>();
+
+ @SuppressWarnings("JdkObsolete")
+ private final LinkedList<Integer> skipWords = new LinkedList<>();
+
+ @SuppressWarnings("JdkObsolete")
+ private final LinkedList<Integer> skipBits = new LinkedList<>();
+
+ FixedBitSetCollector() {}
+
+ @Override
+ protected void doSetNextReader(LeafReaderContext context) throws IOException {
+ this.bitSets.add(null); // lazy allocate when collecting document(s)
+ this.skipWords.add(context.docBase / 64);
+ this.skipBits.add(context.docBase % 64);
+ }
+
+ @Override
+ public void collect(int doc) throws IOException {
+ FixedBitSet bitSet = this.bitSets.getLast();
+ final int idx = this.skipBits.getLast() + doc;
+
+ final int numWords = FixedBitSet.bits2words(idx + 1); // +1 to ensure minimum 1 word
+
+ if (bitSet == null) {
+ this.bitSets.removeLast();
+ bitSet = new FixedBitSet(numWords * 64);
+ this.bitSets.addLast(bitSet);
+
+ } else if (bitSet.getBits().length < numWords) {
+ FixedBitSet smallerBitSet = this.bitSets.removeLast();
+ bitSet = new FixedBitSet(numWords * 64);
+ bitSet.xor(smallerBitSet);
+ this.bitSets.addLast(bitSet);
+ }
+
+ bitSet.set(idx);
+ }
+
+ void update(FixedBitSet allBitSet) {
+ final long[] allBits = allBitSet.getBits();
+ for (int bs_idx = 0; bs_idx < this.bitSets.size(); ++bs_idx) {
+ final FixedBitSet itBitSet = this.bitSets.get(bs_idx);
+ if (itBitSet != null) {
+ final int skipWords = this.skipWords.get(bs_idx);
+ final long[] itBits = itBitSet.getBits();
+ for (int idx = 0; idx < itBits.length && skipWords + idx < allBits.length; ++idx) {
+ allBits[skipWords + idx] ^= itBits[idx];
+ }
+ }
+ }
+ }
+
+ @Override
+ public ScoreMode scoreMode() {
+ return ScoreMode.COMPLETE_NO_SCORES;
+ }
+ }
+
+ static class SearchResult {
+ final ScoreMode scoreMode;
+ private final Object[] result;
+
+ public SearchResult(ScoreMode scoreMode, Object[] result) {
+ this.scoreMode = scoreMode;
+ this.result = result;
+ }
+
+ public TopDocsResult getTopDocsResult() {
+ for (Object res : result) {
+ if (res instanceof TopDocsResult) {
+ return (TopDocsResult) res;
+ }
+ }
+ return null;
+ }
+
+ public float getMaxScore(int totalHits) {
+ if (totalHits > 0) {
+ for (Object res : result) {
+ if (res instanceof MaxScoreResult) {
+ return ((MaxScoreResult) res).maxScore;
+ }
+ }
+ return Float.NaN;
+ } else {
+ return 0.0f;
+ }
+ }
+
+ public FixedBitSet getFixedBitSet() {
+ for (Object res : result) {
+ if (res instanceof FixedBitSet) {
+ return (FixedBitSet) res;
+ }
+ }
+ return null;
+ }
+ }
+
+ private static class MaxScoreCM implements CollectorManager<Collector, Object> {
+ private final Collector[] firstCollectors;
+ private final int firstMaxScoreCollectorIndex;
+
+ public MaxScoreCM(Collector[] firstCollectors, int firstMaxScoreCollectorIndex) {
+ this.firstCollectors = firstCollectors;
+ this.firstMaxScoreCollectorIndex = firstMaxScoreCollectorIndex;
+ }
+
+ @Override
+ public Collector newCollector() throws IOException {
+ MaxScoreCollector collector = new MaxScoreCollector();
+ if (firstCollectors[firstMaxScoreCollectorIndex] == null) {
+ firstCollectors[firstMaxScoreCollectorIndex] = collector;
+ }
+ return collector;
+ }
+
+ @Override
+ @SuppressWarnings("rawtypes")
+ public Object reduce(Collection collectors) throws IOException {
+
+ MaxScoreCollector collector;
+ float maxScore = 0.0f;
+ for (Iterator var4 = collectors.iterator();
+ var4.hasNext();
+ maxScore = Math.max(maxScore, collector.getMaxScore())) {
+ collector = (MaxScoreCollector) var4.next();
+ }
+
+ return new MaxScoreResult(maxScore);
+ }
+ }
+
+ private static class DocSetCM implements CollectorManager<Collector, Object> {
+ private final int maxDoc;
+
+ public DocSetCM(int maxDoc) {
+ this.maxDoc = maxDoc;
+ }
+
+ @Override
+ public Collector newCollector() throws IOException {
+ // TODO: add to firstCollectors here? or if not have comment w.r.t. why not adding
+ return new FixedBitSetCollector();
+ }
+
+ @Override
+ @SuppressWarnings({"rawtypes"})
+ public Object reduce(Collection collectors) throws IOException {
+ final FixedBitSet reduced = new FixedBitSet(maxDoc);
+ for (Object collector : collectors) {
+ if (collector instanceof FixedBitSetCollector) {
+ FixedBitSetCollector fixedBitSetCollector = (FixedBitSetCollector) collector;
+ fixedBitSetCollector.update(reduced);
+ }
+ }
+ return reduced;
+ }
+ }
+
+ private class TopDocsCM implements CollectorManager<Collector, Object> {
+ private final int len;
+ private final QueryCommand cmd;
+ private final Collector[] firstCollectors;
+ private final int firstTopDocsCollectorIndex;
+
+ public TopDocsCM(
+ int len, QueryCommand cmd, Collector[] firstCollectors, int firstTopDocsCollectorIndex) {
+ this.len = len;
+ this.cmd = cmd;
+ this.firstCollectors = firstCollectors;
+ this.firstTopDocsCollectorIndex = firstTopDocsCollectorIndex;
+ }
+
+ @Override
+ public Collector newCollector() throws IOException {
+ @SuppressWarnings("rawtypes")
+ TopDocsCollector collector = searcher.buildTopDocsCollector(len, cmd);
+ if (firstCollectors[firstTopDocsCollectorIndex] == null) {
+ firstCollectors[firstTopDocsCollectorIndex] = collector;
+ }
+ return collector;
+ }
+
+ @Override
+ @SuppressWarnings("rawtypes")
+ public Object reduce(Collection collectors) throws IOException {
+
+ TopDocs[] topDocs = new TopDocs[collectors.size()];
+
+ int totalHits = -1;
+ int i = 0;
+
+ Collector collector;
+ for (Object o : collectors) {
+ collector = (Collector) o;
+ if (collector instanceof TopDocsCollector) {
+ TopDocs td = ((TopDocsCollector) collector).topDocs(0, len);
+ assert td != null : Arrays.asList(topDocs);
+ topDocs[i++] = td;
+ }
+ }
+
+ TopDocs mergedTopDocs = null;
+
+ if (topDocs.length > 0 && topDocs[0] != null) {
+ if (topDocs[0] instanceof TopFieldDocs) {
+ TopFieldDocs[] topFieldDocs =
+ Arrays.copyOf(topDocs, topDocs.length, TopFieldDocs[].class);
+ mergedTopDocs = TopFieldDocs.merge(searcher.weightSort(cmd.getSort()), len, topFieldDocs);
+ } else {
+ mergedTopDocs = TopDocs.merge(0, len, topDocs);
+ }
+ totalHits = (int) mergedTopDocs.totalHits.value;
+ }
+ return new TopDocsResult(mergedTopDocs, totalHits);
+ }
+ }
+
+ static class TopDocsResult {
+ final TopDocs topDocs;
+ final int totalHits;
+
+ public TopDocsResult(TopDocs topDocs, int totalHits) {
+ this.topDocs = topDocs;
+ this.totalHits = totalHits;
+ }
+ }
+}
diff --git a/solr/core/src/java/org/apache/solr/search/QueryCommand.java b/solr/core/src/java/org/apache/solr/search/QueryCommand.java
index 89e585e03ab..a9a2d2ad36c 100755
--- a/solr/core/src/java/org/apache/solr/search/QueryCommand.java
+++ b/solr/core/src/java/org/apache/solr/search/QueryCommand.java
@@ -37,6 +37,7 @@ public class QueryCommand {
private int len;
private int supersetMaxDoc;
private int flags;
+ private boolean multiThreaded = false;
private long timeAllowed = -1;
private int minExactCount = Integer.MAX_VALUE;
private CursorMark cursorMark;
@@ -177,6 +178,15 @@ public class QueryCommand {
return this;
}
+ public boolean getMultiThreaded() {
+ return multiThreaded;
+ }
+
+ public QueryCommand setMultiThreaded(boolean multiThreaded) {
+ this.multiThreaded = multiThreaded;
+ return this;
+ }
+
public long getTimeAllowed() {
return timeAllowed;
}
diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
index 121bfc924b9..7846e56ed35 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
@@ -335,7 +335,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
boolean reserveDirectory,
DirectoryFactory directoryFactory)
throws IOException {
- super(wrapReader(core, r));
+ super(wrapReader(core, r), core.getCoreContainer().getCollectorExecutor());
this.path = path;
this.directoryFactory = directoryFactory;
@@ -1805,7 +1805,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
* @param len the number of docs to return
* @param cmd The Command whose properties should determine the type of TopDocsCollector to use.
*/
- private TopDocsCollector<? extends ScoreDoc> buildTopDocsCollector(int len, QueryCommand cmd)
+ TopDocsCollector<? extends ScoreDoc> buildTopDocsCollector(int len, QueryCommand cmd)
throws IOException {
int minNumFound = cmd.getMinExactCount();
Query q = cmd.getQuery();
@@ -1832,11 +1832,11 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
int last = len;
if (last < 0 || last > maxDoc()) last = maxDoc();
final int lastDocRequested = last;
- final int nDocsReturned;
- final int totalHits;
- final float maxScore;
- final int[] ids;
- final float[] scores;
+ int nDocsReturned = 0;
+ int totalHits;
+ float maxScore;
+ int[] ids;
+ float[] scores;
final boolean needScores = (cmd.getFlags() & GET_SCORES) != 0;
@@ -1891,7 +1891,6 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
buildAndRunCollectorChain(qr, query, collector, cmd, pf.postFilter);
- nDocsReturned = 0;
ids = new int[nDocsReturned];
scores = new float[nDocsReturned];
totalHits = numHits[0];
@@ -1900,25 +1899,51 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
qr.setNextCursorMark(cmd.getCursorMark());
hitsRelation = Relation.EQUAL_TO;
} else {
- final TopDocsCollector<?> topCollector = buildTopDocsCollector(len, cmd);
- MaxScoreCollector maxScoreCollector = null;
- Collector collector = topCollector;
- if (needScores) {
- maxScoreCollector = new MaxScoreCollector();
- collector = MultiCollector.wrap(topCollector, maxScoreCollector);
+ if (log.isDebugEnabled()) {
+ log.debug("calling from 2, query: {}", query.getClass());
+ }
+ final TopDocs topDocs;
+ final ScoreMode scoreModeUsed;
+ if (!MultiThreadedSearcher.allowMT(pf.postFilter, cmd, query)) {
+ if (log.isDebugEnabled()) {
+ log.debug("skipping collector manager");
+ }
+ final TopDocsCollector<?> topCollector = buildTopDocsCollector(len, cmd);
+ MaxScoreCollector maxScoreCollector = null;
+ Collector collector = topCollector;
+ if (needScores) {
+ maxScoreCollector = new MaxScoreCollector();
+ collector = MultiCollector.wrap(topCollector, maxScoreCollector);
+ }
+ scoreModeUsed =
+ buildAndRunCollectorChain(qr, query, collector, cmd, pf.postFilter).scoreMode();
+
+ totalHits = topCollector.getTotalHits();
+ topDocs = topCollector.topDocs(0, len);
+
+ maxScore =
+ totalHits > 0
+ ? (maxScoreCollector == null ? Float.NaN : maxScoreCollector.getMaxScore())
+ : 0.0f;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug("using CollectorManager");
+ }
+ final MultiThreadedSearcher.SearchResult searchResult =
+ new MultiThreadedSearcher(this)
+ .searchCollectorManagers(len, cmd, query, true, needScores, false);
+ scoreModeUsed = searchResult.scoreMode;
+
+ MultiThreadedSearcher.TopDocsResult topDocsResult = searchResult.getTopDocsResult();
+ totalHits = topDocsResult.totalHits;
+ topDocs = topDocsResult.topDocs;
+
+ maxScore = searchResult.getMaxScore(totalHits);
}
- final ScoreMode scoreModeUsed =
- buildAndRunCollectorChain(qr, query, collector, cmd, pf.postFilter).scoreMode();
- totalHits = topCollector.getTotalHits();
- final TopDocs topDocs = topCollector.topDocs(0, len);
hitsRelation = populateScoresIfNeeded(cmd, needScores, topDocs, query, scoreModeUsed);
populateNextCursorMarkFromTopDocs(qr, cmd, topDocs);
- maxScore =
- totalHits > 0
- ? (maxScoreCollector == null ? Float.NaN : maxScoreCollector.getMaxScore())
- : 0.0f;
nDocsReturned = topDocs.scoreDocs.length;
ids = new int[nDocsReturned];
scores = needScores ? new float[nDocsReturned] : null;
@@ -2003,32 +2028,61 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
// no docs on this page, so cursor doesn't change
qr.setNextCursorMark(cmd.getCursorMark());
} else {
- final TopDocsCollector<? extends ScoreDoc> topCollector = buildTopDocsCollector(len, cmd);
- final DocSetCollector setCollector = new DocSetCollector(maxDoc);
- MaxScoreCollector maxScoreCollector = null;
- List<Collector> collectors = new ArrayList<>(Arrays.asList(topCollector, setCollector));
+ final TopDocs topDocs;
+ if (!MultiThreadedSearcher.allowMT(pf.postFilter, cmd, query)) {
+ @SuppressWarnings({"rawtypes"})
+ final TopDocsCollector<? extends ScoreDoc> topCollector = buildTopDocsCollector(len, cmd);
+ final DocSetCollector setCollector = new DocSetCollector(maxDoc);
+ MaxScoreCollector maxScoreCollector = null;
+ List<Collector> collectors = new ArrayList<>(Arrays.asList(topCollector, setCollector));
+
+ if (needScores) {
+ maxScoreCollector = new MaxScoreCollector();
+ collectors.add(maxScoreCollector);
+ }
- if (needScores) {
- maxScoreCollector = new MaxScoreCollector();
- collectors.add(maxScoreCollector);
- }
+ Collector collector = MultiCollector.wrap(collectors);
- final Collector collector = MultiCollector.wrap(collectors);
+ buildAndRunCollectorChain(qr, query, collector, cmd, pf.postFilter);
- buildAndRunCollectorChain(qr, query, collector, cmd, pf.postFilter);
+ set = DocSetUtil.getDocSet(setCollector, this);
- set = DocSetUtil.getDocSet(setCollector, this);
+ totalHits = topCollector.getTotalHits();
+ assert (totalHits == set.size()) || qr.isPartialResults();
- totalHits = topCollector.getTotalHits();
- assert (totalHits == set.size()) || qr.isPartialResults();
+ topDocs = topCollector.topDocs(0, len);
+ maxScore =
+ totalHits > 0
+ ? (maxScoreCollector == null ? Float.NaN : maxScoreCollector.getMaxScore())
+ : 0.0f;
+ } else {
+ log.debug("using CollectorManager");
+
+ boolean needMaxScore = needScores;
+ MultiThreadedSearcher.SearchResult searchResult =
+ new MultiThreadedSearcher(this)
+ .searchCollectorManagers(len, cmd, query, true, needMaxScore, true);
+ MultiThreadedSearcher.TopDocsResult topDocsResult = searchResult.getTopDocsResult();
+ totalHits = topDocsResult.totalHits;
+ topDocs = topDocsResult.topDocs;
+ maxScore = searchResult.getMaxScore(totalHits);
+ set = new BitDocSet(searchResult.getFixedBitSet());
+
+ // TODO: Is this correct?
+ // hitsRelation = populateScoresIfNeeded(cmd, needScores, topDocs, query,
+ // searchResult.scoreMode);
+
+ // nDocsReturned = topDocs.scoreDocs.length;
+ // TODO: Is this correct?
+ // hitsRelation = topDocs.totalHits.relation;
+ // } else {
+ // hitsRelation = Relation.EQUAL_TO;
+ // }
+
+ }
- final TopDocs topDocs = topCollector.topDocs(0, len);
populateScoresIfNeeded(cmd, needScores, topDocs, query, ScoreMode.COMPLETE);
populateNextCursorMarkFromTopDocs(qr, cmd, topDocs);
- maxScore =
- totalHits > 0
- ? (maxScoreCollector == null ? Float.NaN : maxScoreCollector.getMaxScore())
- : 0.0f;
nDocsReturned = topDocs.scoreDocs.length;
ids = new int[nDocsReturned];
diff --git a/solr/core/src/java/org/apache/solr/search/SolrMultiCollectorManager.java b/solr/core/src/java/org/apache/solr/search/SolrMultiCollectorManager.java
new file mode 100644
index 00000000000..e2b7e6fe7af
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/search/SolrMultiCollectorManager.java
@@ -0,0 +1,155 @@
+/*
+ * 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.solr.search;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.Collector;
+import org.apache.lucene.search.CollectorManager;
+import org.apache.lucene.search.FilterScorable;
+import org.apache.lucene.search.LeafCollector;
+import org.apache.lucene.search.MultiCollector;
+import org.apache.lucene.search.Scorable;
+import org.apache.lucene.search.ScoreMode;
+
+/**
+ * A {@link CollectorManager} implements which wrap a set of {@link CollectorManager} as {@link
+ * MultiCollector} acts for {@link Collector}.
+ */
+public class SolrMultiCollectorManager
+ implements CollectorManager<SolrMultiCollectorManager.Collectors, Object[]> {
+
+ private final CollectorManager<Collector, ?>[] collectorManagers;
+
+ @SafeVarargs
+ @SuppressWarnings({"varargs", "unchecked"})
+ public SolrMultiCollectorManager(
+ final CollectorManager<? extends Collector, ?>... collectorManagers) {
+ if (collectorManagers.length < 1) {
+ throw new IllegalArgumentException("There must be at least one collector");
+ }
+ this.collectorManagers = (CollectorManager[]) collectorManagers;
+ }
+
+ @Override
+ public Collectors newCollector() throws IOException {
+ return new Collectors();
+ }
+
+ @Override
+ public Object[] reduce(Collection<Collectors> reducableCollectors) throws IOException {
+ final int size = reducableCollectors.size();
+ final Object[] results = new Object[collectorManagers.length];
+ for (int i = 0; i < collectorManagers.length; i++) {
+ final List<Collector> reducableCollector = new ArrayList<>(size);
+ for (Collectors collectors : reducableCollectors)
+ reducableCollector.add(collectors.collectors[i]);
+ results[i] = collectorManagers[i].reduce(reducableCollector);
+ }
+ return results;
+ }
+
+ // TODO: could Lucene's MultiCollector permit reuse of its logic?
+ public static ScoreMode scoreMode(Collector[] collectors) {
+ ScoreMode scoreMode = null;
+ for (Collector collector : collectors) {
+ if (scoreMode == null) {
+ scoreMode = collector.scoreMode();
+ } else if (scoreMode != collector.scoreMode()) {
+ return ScoreMode.COMPLETE;
+ }
+ }
+ return scoreMode;
+ }
+
+ /** Wraps multiple collectors for processing */
+ class Collectors implements Collector {
+
+ private final Collector[] collectors;
+
+ private Collectors() throws IOException {
+ collectors = new Collector[collectorManagers.length];
+ for (int i = 0; i < collectors.length; i++)
+ collectors[i] = collectorManagers[i].newCollector();
+ }
+
+ @Override
+ public final LeafCollector getLeafCollector(final LeafReaderContext context)
+ throws IOException {
+ return new LeafCollectors(context, scoreMode() == ScoreMode.TOP_SCORES);
+ }
+
+ @Override
+ public final ScoreMode scoreMode() {
+ return SolrMultiCollectorManager.scoreMode(collectors);
+ }
+
+ /**
+ * Wraps multiple leaf collectors and delegates collection across each one
+ *
+ * @lucene.internal
+ */
+ private class LeafCollectors implements LeafCollector {
+
+ private final LeafCollector[] leafCollectors;
+ private final boolean skipNonCompetitiveScores;
+
+ private LeafCollectors(final LeafReaderContext context, boolean skipNonCompetitiveScores)
+ throws IOException {
+ this.skipNonCompetitiveScores = skipNonCompetitiveScores;
+ leafCollectors = new LeafCollector[collectors.length];
+ for (int i = 0; i < collectors.length; i++)
+ leafCollectors[i] = collectors[i].getLeafCollector(context);
+ }
+
+ @Override
+ public final void setScorer(final Scorable scorer) throws IOException {
+ if (skipNonCompetitiveScores) {
+ for (LeafCollector leafCollector : leafCollectors)
+ if (leafCollector != null) leafCollector.setScorer(scorer);
+ } else {
+ FilterScorable fScorer =
+ new FilterScorable(scorer) {
+ @Override
+ public void setMinCompetitiveScore(float minScore) throws IOException {
+ // Ignore calls to setMinCompetitiveScore so that if we wrap two
+ // collectors and one of them wants to skip low-scoring hits, then
+ // the other collector still sees all hits.
+ }
+ };
+ for (LeafCollector leafCollector : leafCollectors) {
+ if (leafCollector != null) {
+ leafCollector.setScorer(fScorer);
+ }
+ }
+ }
+ }
+
+ @Override
+ public final void collect(final int doc) throws IOException {
+ for (LeafCollector leafCollector : leafCollectors) {
+ if (leafCollector != null) {
+ leafCollector.collect(doc);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/solr/core/src/test-files/solr/solr-50-all.xml b/solr/core/src/test-files/solr/solr-50-all.xml
index 6ae05f943c8..71c676c30b1 100644
--- a/solr/core/src/test-files/solr/solr-50-all.xml
+++ b/solr/core/src/test-files/solr/solr-50-all.xml
@@ -30,6 +30,7 @@
<str name="coreSorter">testCoreSorter</str>
<int name="transientCacheSize">66</int>
<int name="replayUpdatesThreads">100</int>
+ <int name="indexSearcherExecutorThreads">7</int>
<int name="maxBooleanClauses">42</int>
<bool name="hideStackTrace">true</bool>
diff --git a/solr/core/src/test-files/solr/solr-stress-new.xml b/solr/core/src/test-files/solr/solr-stress-new.xml
index 24b2719a118..4e5bc8df6bc 100644
--- a/solr/core/src/test-files/solr/solr-stress-new.xml
+++ b/solr/core/src/test-files/solr/solr-stress-new.xml
@@ -21,6 +21,7 @@
-->
<solr>
+ <int name="indexSearcherExecutorThreads">4</int>
<solrcloud>
<str name="host">127.0.0.1</str>
<int name="hostPort">8983</int>
diff --git a/solr/core/src/test-files/solr/solr-trackingshardhandler.xml b/solr/core/src/test-files/solr/solr-trackingshardhandler.xml
index 491d6460151..eb24861138a 100644
--- a/solr/core/src/test-files/solr/solr-trackingshardhandler.xml
+++ b/solr/core/src/test-files/solr/solr-trackingshardhandler.xml
@@ -24,6 +24,7 @@
<str name="shareSchema">${shareSchema:false}</str>
<str name="configSetBaseDir">${configSetBaseDir:configsets}</str>
<str name="coreRootDirectory">${coreRootDirectory:.}</str>
+ <int name="indexSearcherExecutorThreads">4</int>
<solrcloud>
<str name="host">127.0.0.1</str>
diff --git a/solr/core/src/test-files/solr/solr.xml b/solr/core/src/test-files/solr/solr.xml
index f8065f741e6..283e1aeb165 100644
--- a/solr/core/src/test-files/solr/solr.xml
+++ b/solr/core/src/test-files/solr/solr.xml
@@ -29,6 +29,7 @@
<str name="allowPaths">${solr.allowPaths:}</str>
<str name="allowUrls">${solr.tests.allowUrls:}</str>
<bool name="hideStackTrace">${solr.hideStackTrace:true}</bool>
+ <int name="indexSearcherExecutorThreads">4</int>
<shardHandlerFactory name="shardHandlerFactory" class="HttpShardHandlerFactory">
<str name="urlScheme">${urlScheme:}</str>
diff --git a/solr/core/src/test/org/apache/solr/search/TestCpuAllowedLimit.java b/solr/core/src/test/org/apache/solr/search/TestCpuAllowedLimit.java
index dac4ec5124c..ea02e448da8 100644
--- a/solr/core/src/test/org/apache/solr/search/TestCpuAllowedLimit.java
+++ b/solr/core/src/test/org/apache/solr/search/TestCpuAllowedLimit.java
@@ -185,7 +185,9 @@ public class TestCpuAllowedLimit extends SolrCloudTestCase {
"stages",
"prepare,process",
"cpuAllowed",
- "50"));
+ "50",
+ "multiThreaded",
+ "false"));
// System.err.println("rsp=" + rsp.jsonStr());
assertNotNull("should have partial results", rsp.getHeader().get("partialResults"));
@@ -204,7 +206,9 @@ public class TestCpuAllowedLimit extends SolrCloudTestCase {
"stages",
"prepare,process",
"cpuAllowed",
- "50"));
+ "50",
+ "multiThreaded",
+ "false"));
// System.err.println("rsp=" + rsp.jsonStr());
assertNotNull("should have partial results", rsp.getHeader().get("partialResults"));
}
diff --git a/solr/core/src/test/org/apache/solr/search/TestFiltering.java b/solr/core/src/test/org/apache/solr/search/TestFiltering.java
index 5d9ad6bb9da..e9194e170f9 100644
--- a/solr/core/src/test/org/apache/solr/search/TestFiltering.java
+++ b/solr/core/src/test/org/apache/solr/search/TestFiltering.java
@@ -22,6 +22,7 @@ import java.util.List;
import java.util.Locale;
import org.apache.lucene.search.DocIdSetIterator;
import org.apache.lucene.search.Query;
+import org.apache.lucene.util.Bits;
import org.apache.lucene.util.FixedBitSet;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.common.SolrInputDocument;
@@ -92,14 +93,14 @@ public class TestFiltering extends SolrTestCaseJ4 {
QueryResult res = new QueryResult();
searcher.search(res, cmd);
set = res.getDocSet();
- assertSame(set, live);
+ assertEffectivelySame(set.getFixedBitSet(), live.getFixedBitSet());
cmd.setQuery(QParser.getParser(qstr + " OR id:0", null, req).getQuery());
cmd.setFilterList(QParser.getParser(qstr + " OR id:1", null, req).getQuery());
res = new QueryResult();
searcher.search(res, cmd);
set = res.getDocSet();
- assertSame(set, live);
+ assertEffectivelySame(set.getFixedBitSet(), live.getFixedBitSet());
}
} finally {
@@ -107,6 +108,19 @@ public class TestFiltering extends SolrTestCaseJ4 {
}
}
+ /** If the a XOR b == 0, then both a & b are effectively the same bitset */
+ private void assertEffectivelySame(FixedBitSet a, FixedBitSet b) {
+ FixedBitSet xor = a.clone();
+ xor.xor(b);
+ assertEquals(new FixedBitSet(xor.length()), xor);
+ }
+
+ private String bitsString(Bits bits) {
+ StringBuilder s = new StringBuilder();
+ for (int i = 0; i < bits.length(); i++) s.append(bits.get(i) ? 1 : 0);
+ return s.toString();
+ }
+
public void testCaching() throws Exception {
clearIndex();
assertU(adoc("id", "4", "val_i", "1"));
diff --git a/solr/core/src/test/org/apache/solr/search/TestQueryLimits.java b/solr/core/src/test/org/apache/solr/search/TestQueryLimits.java
index 6e413f6bfd2..ae1b0a32d6c 100644
--- a/solr/core/src/test/org/apache/solr/search/TestQueryLimits.java
+++ b/solr/core/src/test/org/apache/solr/search/TestQueryLimits.java
@@ -76,7 +76,17 @@ public class TestQueryLimits extends SolrCloudTestCase {
rsp =
solrClient.query(
COLLECTION,
- params("q", "id:*", "sort", "id asc", "facet", "true", "facet.field", "val_i"));
+ params(
+ "q",
+ "id:*",
+ "sort",
+ "id asc",
+ "facet",
+ "true",
+ "facet.field",
+ "val_i",
+ "multiThreaded",
+ "false"));
assertNotNull(
"should have partial results for expr " + matchingExpr,
rsp.getHeader().get("partialResults"));
diff --git a/solr/server/solr/solr.xml b/solr/server/solr/solr.xml
index afcd6eaa238..ed1f876759d 100644
--- a/solr/server/solr/solr.xml
+++ b/solr/server/solr/solr.xml
@@ -34,6 +34,7 @@
<str name="allowPaths">${solr.allowPaths:}</str>
<str name="allowUrls">${solr.allowUrls:}</str>
<str name="hideStackTrace">${solr.hideStackTrace:false}</str>
+ <int name="indexSearcherExecutorThreads">${solr.searchThreads:4}</int>
<solrcloud>
diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc
index a4543d583f6..66d6d661d62 100644
--- a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc
+++ b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc
@@ -180,6 +180,15 @@ Specifies the number of threads that will be assigned to replay updates in paral
This pool is shared for all cores of the node.
The default value is equal to the number of processors.
+`indexSearcherExecutorThreads`::
++
+[%autowidth,frame=none]
+|===
+|Optional |Default: 4
+|===
++
+Specifies the number of threads that will be assigned for search queries.
+
`coreRootDirectory`::
+
[%autowidth,frame=none]