accumulo-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Keith Turner <ke...@deenlo.com>
Subject Re: BatchWriter Improvements - An end user's perspective
Date Mon, 29 Aug 2016 20:24:19 GMT
On Fri, Aug 26, 2016 at 12:21 PM, Michael Moss <michael.moss@gmail.com> wrote:
> Hello, Folks.
>
> As I look at the following tickets, I thought it might be useful to share
> how we are using the BatchWriter, some of the challenges we've had, some
> thoughts about it's redesign and how we might get involved.
>
> https://issues.apache.org/jira/browse/ACCUMULO-4154
> https://issues.apache.org/jira/browse/ACCUMULO-2589
> https://issues.apache.org/jira/browse/ACCUMULO-2990
>
> One of our primary use cases of the BatchWriter is from within a Storm
> topology, reading from Kafka. Generally speaking, storm might be persisting
> a a single or small set of mutations at a time (low latency), or in larger
> batches with Trident (higher throughput). In addition to ACCUMULO-2990 (any
> TimedOutException, which then throws MutationsRejectedException and
> requires a new connection to be made), one of our requirements is to ensure
> that any given thread's mutations are the ones which are flushed and none
> others (pseudo transactions). Otherwise, we might get a failure for a
> mutation which belongs to another thread (and already ACKed by Storm) which
> means we don't have a 'handle' on that offset anymore in Kafka to replay
> the failure - i.e. the message could be 'lost'.
>
> Despite being threadsafe, we end up using a single BatchWriter per thread

How many threads are you having each batch writer use?

> to make reasoning about the above simpler, but this creates a resource
> issue - number of connections to accumulo and zk.
>
> This all makes me wonder what the design goals might have been for the
> current version of the driver and if the efforts to rewrite it might
> benefit from incorporating elements to address some of these use cases
> above.
>
> What can we learn from how drivers for other "NoSQL" databases are
> implemented? Would it make sense to remove all the global variables
> ("somethingFailed"), thread sleep/notify, frequent calls to
> "checkForFailures()" and consider using a 'connection pool' model where
> writes are single-threaded, linearized and isolated during the connection
> lease? Could we make the client non-blocking and with optional pipelining,
> so multiple writes could share a connection and allow interleaving of
> operations (with individual acks)?

I am hoping to work on async batch writer, conditional writter, and
scanners at some point.   I think this may address some of the things
you brought up.   If I do start working on it, I will seek input as
early as possible.  For example if we had something that accepted a
batch of mutation to write and returned a
CompletableFuture<BatchResult>, then BatchResult could relay failure
information only related to that batch.  Also, flush() may not be
needed since a user could just wait on the future if desired.

I'm hoping when something like this exist in the API, optimizations
like pipelining could be made later if not done when its added.

>
> Looking forward to hearing everyone's thoughts.
>
> -Mike

Mime
View raw message