Examples with QueueResizingOpenSearchThreadPoolExecutor org.opensearch.common.util.concurrent.QueueResizingOpenSearchThreadPoolExecutor used on opensource projects

Example 1 with QueueResizingOpenSearchThreadPoolExecutor

use of org.opensearch.common.util.concurrent.QueueResizingOpenSearchThreadPoolExecutor in project OpenSearch by opensearch-project.

the class QueryPhase method executeInternal.

/**
 * In a package-private method so that it can be tested without having to
 * wire everything (mapperService, etc.)
 * @return whether the rescoring phase should be executed
 */
static boolean executeInternal(SearchContext searchContext) throws QueryPhaseExecutionException {
    final ContextIndexSearcher searcher = searchContext.searcher();
    final IndexReader reader = searcher.getIndexReader();
    QuerySearchResult queryResult = searchContext.queryResult();
    queryResult.searchTimedOut(false);
    try {
        queryResult.from(searchContext.from());
        queryResult.size(searchContext.size());
        Query query = searchContext.query();
        // already rewritten
        assert query == searcher.rewrite(query);
        final ScrollContext scrollContext = searchContext.scrollContext();
        if (scrollContext != null) {
            if (scrollContext.totalHits == null) {
                // first round
                assert scrollContext.lastEmittedDoc == null;
            // there is not much that we can optimize here since we want to collect all
            // documents in order to get the total number of hits
            } else {
                final ScoreDoc after = scrollContext.lastEmittedDoc;
                if (returnsDocsInOrder(query, searchContext.sort())) {
                    // skip to the desired doc
                    if (after != null) {
                        query = new BooleanQuery.Builder().add(query, BooleanClause.Occur.MUST).add(new MinDocQuery(after.doc + 1), BooleanClause.Occur.FILTER).build();
                    }
                    // ... and stop collecting after ${size} matches
                    searchContext.terminateAfter(searchContext.size());
                } else if (canEarlyTerminate(reader, searchContext.sort())) {
                    // skip to the desired doc
                    if (after != null) {
                        query = new BooleanQuery.Builder().add(query, BooleanClause.Occur.MUST).add(new SearchAfterSortedDocQuery(searchContext.sort().sort, (FieldDoc) after), BooleanClause.Occur.FILTER).build();
                    }
                }
            }
        }
        final LinkedList<QueryCollectorContext> collectors = new LinkedList<>();
        // whether the chain contains a collector that filters documents
        boolean hasFilterCollector = false;
        if (searchContext.terminateAfter() != SearchContext.DEFAULT_TERMINATE_AFTER) {
            // add terminate_after before the filter collectors
            // it will only be applied on documents accepted by these filter collectors
            collectors.add(createEarlyTerminationCollectorContext(searchContext.terminateAfter()));
            // this collector can filter documents during the collection
            hasFilterCollector = true;
        }
        if (searchContext.parsedPostFilter() != null) {
            // add post filters before aggregations
            // it will only be applied to top hits
            collectors.add(createFilteredCollectorContext(searcher, searchContext.parsedPostFilter().query()));
            // this collector can filter documents during the collection
            hasFilterCollector = true;
        }
        if (searchContext.queryCollectors().isEmpty() == false) {
            // plug in additional collectors, like aggregations
            collectors.add(createMultiCollectorContext(searchContext.queryCollectors().values()));
        }
        if (searchContext.minimumScore() != null) {
            // apply the minimum score after multi collector so we filter aggs as well
            collectors.add(createMinScoreCollectorContext(searchContext.minimumScore()));
            // this collector can filter documents during the collection
            hasFilterCollector = true;
        }
        // optimizing sort on Numerics (long and date)
        if ((searchContext.sort() != null) && SYS_PROP_REWRITE_SORT) {
            enhanceSortOnNumeric(searchContext, searcher.getIndexReader());
        }
        boolean timeoutSet = scrollContext == null && searchContext.timeout() != null && searchContext.timeout().equals(SearchService.NO_TIMEOUT) == false;
        final Runnable timeoutRunnable;
        if (timeoutSet) {
            final long startTime = searchContext.getRelativeTimeInMillis();
            final long timeout = searchContext.timeout().millis();
            final long maxTime = startTime + timeout;
            timeoutRunnable = searcher.addQueryCancellation(() -> {
                final long time = searchContext.getRelativeTimeInMillis();
                if (time > maxTime) {
                    throw new TimeExceededException();
                }
            });
        } else {
            timeoutRunnable = null;
        }
        if (searchContext.lowLevelCancellation()) {
            searcher.addQueryCancellation(() -> {
                SearchShardTask task = searchContext.getTask();
                if (task != null && task.isCancelled()) {
                    throw new TaskCancelledException("cancelled task with reason: " + task.getReasonCancelled());
                }
            });
        }
        try {
            boolean shouldRescore = searchWithCollector(searchContext, searcher, query, collectors, hasFilterCollector, timeoutSet);
            ExecutorService executor = searchContext.indexShard().getThreadPool().executor(ThreadPool.Names.SEARCH);
            if (executor instanceof QueueResizingOpenSearchThreadPoolExecutor) {
                QueueResizingOpenSearchThreadPoolExecutor rExecutor = (QueueResizingOpenSearchThreadPoolExecutor) executor;
                queryResult.nodeQueueSize(rExecutor.getCurrentQueueSize());
                queryResult.serviceTimeEWMA((long) rExecutor.getTaskExecutionEWMA());
            }
            return shouldRescore;
        } finally {
            // otherwise aggregation phase might get cancelled.
            if (timeoutRunnable != null) {
                searcher.removeQueryCancellation(timeoutRunnable);
            }
        }
    } catch (Exception e) {
        throw new QueryPhaseExecutionException(searchContext.shardTarget(), "Failed to execute main query", e);
    }
}