[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14361107#comment-14361107 ] T Jake Luciani commented on CASSANDRA-8449: --- I've updated my branch with the oporder approach for netty and message service requests. There are still edges like dropped messages and internal cql requests I need to cover. As well as hints and batchlog replay (though those are compressed so shouldn't be an issue regardless). I've added a unit test using ByteMan http://byteman.jboss.org/ to inject pauses in the pipeline that cause the jvm to crash without the correct oporder code. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14359434#comment-14359434 ] Benedict commented on CASSANDRA-8449: - bq. -carrot- casus belli FTFY :) > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14359425#comment-14359425 ] Aleksey Yeschenko commented on CASSANDRA-8449: -- bq. I'm thinking for thrift I just revert to non-zero-copy behavior if the thrift rpc is running. Out of context, just commenting on this quote: in 3.0 thrift will be off by default, and better performance with thrift disabled would be a good carrot. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14359329#comment-14359329 ] T Jake Luciani commented on CASSANDRA-8449: --- bq. For thrift this is trickier I'm thinking for thrift I just revert to non-zero-copy behavior if the thrift rpc is running. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14249688#comment-14249688 ] Benedict commented on CASSANDRA-8449: - We can't hoist that one out to the outer layer because if something went wrong it would be tragic, as the system would keel over by being unable to reclaim memtable space. I agree this may not be worth the investment, although I don't know that mmap is so underutilised - for anyone with spare IO lying around, or datasets small enough to fit in-memory, mmap is likely to be the access method of choice. Implementing this change for the netty client is relatively easy: we can simply open/close our OpOrder reference in Message.Despatcher. For thrift this is trickier, as we need to modify the generated code or need to invoke a method before and after each RPC completes. I'm not sufficiently familiar with thrift to know how easy this is to achieve. I suspect the internode messages will actually be the trickiest to get right. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14249015#comment-14249015 ] T Jake Luciani commented on CASSANDRA-8449: --- Looks like there is already a CFS.readOrdering barrier in scheduleTidy. The problem is readOrdering is only started at the CFS.getTopLevelColumns() level, which means the data could be dropped before it's written to the output buffer. We could move this to the ReadCommand level which would cover internode messages via the verb handlers. But for local read commands we would need to push this all the way to the netty/thrift level perhaps push the opOrder into a wrapper around List On the other hand this is a lot of effort for something that isn't wildly used anymore. CASSANDRA-8464 is much more relevant and doesn't have this issue. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14248359#comment-14248359 ] T Jake Luciani commented on CASSANDRA-8449: --- Yes > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14248358#comment-14248358 ] Jonathan Ellis commented on CASSANDRA-8449: --- Jake, are you taking a stab at the OpOrder approach? > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14242439#comment-14242439 ] Benedict commented on CASSANDRA-8449: - bq. Isn't the existing use of OpOrder technically "arbitrarily long" due to GC for instance Any delay caused by GC to the termination of an OpOrder.Group is instantaneous from the point of view of the waiter, since it is also delayed by GC Either way, GC is not as arbitrarily long as I was referring to. Mostly I'm thinking about network consumers that haven't died but are, perhaps, in the process of doing so (GC death spiral), or where the network socket has frozen due to some other problem. i.e. where the problem is isolated from the rest of the host's functionality, but by being guarded by an OpOrder could conceivably cause the problem to infect the whole host's functionality. In reality we can probably guard against most of the risk, but I would still be reticent to use this scheme with that risk even minimally present without the ramifications being constrained as they are here. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241737#comment-14241737 ] Jonathan Ellis commented on CASSANDRA-8449: --- Right, even after 7392 a timeout approach is dangerous. bq. Typically I would not want to use this approach for guarding operations that could take arbitrarily long, but really all we're sacrificing is virtual address space Can you spell that out for me? Isn't the existing use of OpOrder technically "arbitrarily long" due to GC for instance? > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241215#comment-14241215 ] Benedict commented on CASSANDRA-8449: - CASSANDRA-7705 is really designed for situations where we know there won't be loads in-flight; i'd prefer not to reintroduce excessive long-lifetime reference counting onto the read critical path (we don't ref count sstable readers anymore, since CASSANDRA-6919). All we're doing here is delaying when we unmap the file until a time it is known to be unused, so we could create a global OpOrder that guards against this; all requests that hit the node are guarded by the OpOrder for their entire duration, and only once _all_ requests that started prior to _thinking_ the data is free do we actually free it. Typically I would not want to use this approach for guarding operations that could take arbitrarily long, but really all we're sacrificing is virtual address space, so being delayed more than you expect (even excessively) should not noticeably impact system performance, as the OS can choose to drop those pages on the floor, keeping only the mapping overhead. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241173#comment-14241173 ] T Jake Luciani commented on CASSANDRA-8449: --- Hmm yeah, if there was a pause before serializing the message and compaction was running you would still segfault. I was going to initially try using reference queue and weak references to track when the byte buffer but any .duplicate() would break that model. [~benedict] perhaps we can use CASSANDRA-7705 to manage this? > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241151#comment-14241151 ] Ariel Weisberg commented on CASSANDRA-8449: --- It's not just junk data right? If the file is unmapped it would probably segfault. I think you need to reference count the file. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241005#comment-14241005 ] Aleksey Yeschenko commented on CASSANDRA-8449: -- Fair enough. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14241004#comment-14241004 ] Benedict commented on CASSANDRA-8449: - Depending on how that is implemented. I will go out on a limb and predict it will offer no such guarantee, as there will always be a potential race condition (easily triggered by e.g. lengthy GC pauses) without enforcing the constraint _after_ performing the copy to the transport buffers, which is a very specific condition that I don't think is being considered for CASSANDRA-7392. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14240995#comment-14240995 ] Aleksey Yeschenko commented on CASSANDRA-8449: -- We will, but only once we have CASSANDRA-7392. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14240975#comment-14240975 ] Benedict commented on CASSANDRA-8449: - Unless we explicitly force all queries to yield a timeout response even if they have successfully terminated after the timeout, and we enforce this constraint _after_ copying the data to the output buffers (netty and thrift), this is guaranteed to return junk data to a user somewhere, sometime. So I am -1 on this approach. > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Assignee: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (CASSANDRA-8449) Allow zero-copy reads again
[ https://issues.apache.org/jira/browse/CASSANDRA-8449?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14240121#comment-14240121 ] T Jake Luciani commented on CASSANDRA-8449: --- Patch is here https://github.com/tjake/cassandra/tree/mmap-uncompressed > Allow zero-copy reads again > --- > > Key: CASSANDRA-8449 > URL: https://issues.apache.org/jira/browse/CASSANDRA-8449 > Project: Cassandra > Issue Type: Improvement >Reporter: T Jake Luciani >Priority: Minor > Labels: performance > Fix For: 3.0 > > > We disabled zero-copy reads in CASSANDRA-3179 due to in flight reads > accessing a ByteBuffer when the data was unmapped by compaction. Currently > this code path is only used for uncompressed reads. > The actual bytes are in fact copied to the client output buffers for both > netty and thrift before being sent over the wire, so the only issue really is > the time it takes to process the read internally. > This patch adds a slow network read test and changes the tidy() method to > actually delete a sstable once the readTimeout has elapsed giving plenty of > time to serialize the read. > Removing this copy causes significantly less GC on the read path and improves > the tail latencies: > http://cstar.datastax.com/graph?stats=c0c8ce16-7fea-11e4-959d-42010af0688f&metric=gc_count&operation=2_read&smoothing=1&show_aggregates=true&xmin=0&xmax=109.34&ymin=0&ymax=5.5 -- This message was sent by Atlassian JIRA (v6.3.4#6332)