lucene-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Mark Miller (JIRA)" <>
Subject [jira] [Commented] (SOLR-9824) Documents indexed in bulk are replicated using too many HTTP requests
Date Fri, 09 Dec 2016 06:41:58 GMT


Mark Miller commented on SOLR-9824:

bq. It may be safer to ensure that interrupt() only affects the queue.poll calls and not anything

It's fine - in our case we know all the outstanding documents have been added to the queue
by the time we are in the blockuntilfinished block. We don't access CUSS in a multi threaded
manner. Once we are in blockUntilFinished and the queue is empty, we know we are just interrupting

We want to use CUSS internally because I don't want to dupe a bunch of this logic. But our
use case and it's general use case are very different. We shouldn't try to fit both use cases
in the same box.

This option will be for use cases like ours. You are not just keeping a server around to pull
and use to add docs as needed over time. You are creating a instance for a known load of docs,
it's going away after that load, and you don't want to spin up or down connections or threads,
and we access the CUSS instance single threaded. That is the case we need to optimize for.
I'm much less interested in improving CUSS for non internal use anyway, I'd rather spin any
changes for that use case into another issue. It's really not a great client for SolrCloud
for a lot of other reasons. And it's very easy to introduce bugs with changes that look like
they don't hurt. We have seen those same types of changes hurt before.

> Documents indexed in bulk are replicated using too many HTTP requests
> ---------------------------------------------------------------------
>                 Key: SOLR-9824
>                 URL:
>             Project: Solr
>          Issue Type: Improvement
>      Security Level: Public(Default Security Level. Issues are Public) 
>          Components: SolrCloud
>    Affects Versions: 6.3
>            Reporter: David Smiley
>         Attachments: SOLR-9824.patch, SOLR-9824.patch, SOLR-9824.patch
> This takes awhile to explain; bear with me. While working on bulk indexing small documents,
I looked at the logs of my SolrCloud nodes.  I noticed that shards would see an /update log
message every ~6ms which is *way* too much.  These are requests from one shard (that isn't
a leader/replica for these docs but the recipient from my client) to the target shard leader
(no additional replicas).  One might ask why I'm not sending docs to the right shard in the
first place; I have a reason but it's besides the point -- there's a real Solr perf problem
here and this probably applies equally to replicationFactor>1 situations too.  I could
turn off the logs but that would hide useful stuff, and it's disconcerting to me that so many
short-lived HTTP requests are happening, somehow at the bequest of DistributedUpdateProcessor.
 After lots of analysis and debugging and hair pulling, I finally figured it out.  
> In SOLR-7333 ([~tpot]) introduced an optimization called {{UpdateRequest.isLastDocInBatch()}}
in which ConcurrentUpdateSolrClient will poll with a '0' timeout to the internal queue, so
that it can close the connection without it hanging around any longer than needed.  This part
makes sense to me.  Currently the only spot that has the smarts to set this flag is {{JavaBinUpdateRequestCodec.unmarshal.readOuterMostDocIterator()}}
at the last document.  So if a shard received docs in a javabin stream (but not other formats)
one would expect the _last_ document to have this flag.  There's even a test.  Docs without
this flag get the default poll time; for javabin it's 25ms.  Okay.
> I _suspect_ that if someone used CloudSolrClient or HttpSolrClient to send javabin data
in a batch, the intended efficiencies of SOLR-7333 would apply.  I didn't try. In my case,
I'm using ConcurrentUpdateSolrClient (and BTW DistributedUpdateProcessor uses CUSC too). 
CUSC uses the RequestWriter (defaulting to javabin) to send each document separately without
any leading marker or trailing marker.  For the XML format by comparison, there is a leading
and trailing marker (<stream> ... </stream>).  Since there's no outer container
for the javabin unmarshalling to detect the last document, it marks _every_ document as {{req.lastDocInBatch()}}!

This message was sent by Atlassian JIRA

To unsubscribe, e-mail:
For additional commands, e-mail:

View raw message