Reduce ByteBuffer duplication when resizing pooled direct ByteBufs #9765
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
Can one of the admins verify this patch? |
|
@netty-bot test this please |
normanmaurer
reviewed
Nov 8, 2019
| @@ -402,7 +402,9 @@ void reallocate(PooledByteBuf<T> buf, int newCapacity, boolean freeOldMemory) { | |||
| buf.trimIndicesToCapacity(newCapacity); | |||
| bytesToCopy = newCapacity; | |||
| } | |||
| memoryCopy(oldMemory, oldOffset, buf.memory, buf.offset, bytesToCopy); | |||
| if (bytesToCopy > 0) { | |||
| oldNioBuffer = memoryCopy(oldMemory, oldNioBuffer, oldOffset, buf, bytesToCopy); | |||
There was a problem hiding this comment.
hmm is this really correct ? This may now be duplicate that is passed to free(...)
There was a problem hiding this comment.
@normanmaurer the oldNioBuffer passed there is already a duplicate (comes from buf.tmpNioBuf) and isn't free'd itself, rather kept in the cache for later re-use by other ByteBufs that share the same "root" nio buffer...
|
@njhill honestly I wonder if this change really worth it... I mean it makes things more complex and resizing should be "hopefully" not happen too often. Or I am missing anything ? |
|
@normanmaurer that's a fair point... I noticed this while looking closer at the underlying buffer manipulation done in |
njhill
force-pushed
the
less-niobuf-dups
branch
from
bb789b7
to
34d7054
Compare
|
@netty-bot test this please |
|
@njhill can you update the commit message and pr description to match what you did now ? |
Motivation Currently when use of Unsafe is disabled and an internal reallocation is performed for a direct PooledByteBuf, a one-off temporary duplicate is made of the source and destination backing nio buffers so that the copy can be done in a threadsafe manner. The need for this can be reduced by sharing the temporary duplicate buffer that is already stored in the corresponding destination PooledByteBuf instance. Modifications Have PoolArena#memoryCopy(...) take the destination PooledByteBuf instead of the underlying mem reference and offset, and use internalNioBuffer() to obtain/initialize a reusable duplicate of the backing nio buffer. Result Fewer temporary allocations when resizing direct pooled ByteBufs in the non-Unsafe case
njhill
force-pushed
the
less-niobuf-dups
branch
from
34d7054
to
7d0baf6
Compare
|
@normanmaurer done |
|
@netty-bot test this please |
|
@njhill thanks.. and sorry for the delay. |
normanmaurer
pushed a commit
that referenced
this pull request
Nov 16, 2019
…9765) Motivation: Currently when use of Unsafe is disabled and an internal reallocation is performed for a direct PooledByteBuf, a one-off temporary duplicate is made of the source and destination backing nio buffers so that the copy can be done in a threadsafe manner. The need for this can be reduced by sharing the temporary duplicate buffer that is already stored in the corresponding destination PooledByteBuf instance. Modifications: Have PoolArena#memoryCopy(...) take the destination PooledByteBuf instead of the underlying mem reference and offset, and use internalNioBuffer() to obtain/initialize a reusable duplicate of the backing nio buffer. Result: Fewer temporary allocations when resizing direct pooled ByteBufs in the non-Unsafe case
njhill
added a commit
to njhill/netty
that referenced
this pull request
Dec 30, 2019
Motivation Recent optimization netty#9765 introduced a bug where the native indices of the internal reused duplicate nio buffer are not properly reset prior to using it to copy data during a reallocation operation. This can result in BufferOverflowExceptions thrown during ByteBuf capacity changes. The code path in question applies only to pooled direct buffers when Unsafe is disabled or not available. Modification Ensure ByteBuffer#clear() is always called on the reused internal nio buffer prior to returning it from PooledByteBuf#internalNioBuffer() (protected method); add unit test that exposes the bug. Result Fixes netty#9911
normanmaurer
pushed a commit
that referenced
this pull request
Jan 11, 2020
…ize (#9912) Motivation Recent optimization #9765 introduced a bug where the native indices of the internal reused duplicate nio buffer are not properly reset prior to using it to copy data during a reallocation operation. This can result in BufferOverflowExceptions thrown during ByteBuf capacity changes. The code path in question applies only to pooled direct buffers when Unsafe is disabled or not available. Modification Ensure ByteBuffer#clear() is always called on the reused internal nio buffer prior to returning it from PooledByteBuf#internalNioBuffer() (protected method); add unit test that exposes the bug. Result Fixes #9911
normanmaurer
pushed a commit
that referenced
this pull request
Jan 11, 2020
…ize (#9912) Motivation Recent optimization #9765 introduced a bug where the native indices of the internal reused duplicate nio buffer are not properly reset prior to using it to copy data during a reallocation operation. This can result in BufferOverflowExceptions thrown during ByteBuf capacity changes. The code path in question applies only to pooled direct buffers when Unsafe is disabled or not available. Modification Ensure ByteBuffer#clear() is always called on the reused internal nio buffer prior to returning it from PooledByteBuf#internalNioBuffer() (protected method); add unit test that exposes the bug. Result Fixes #9911
ihanyong
pushed a commit
to ihanyong/netty
that referenced
this pull request
Jul 31, 2020
…ize (netty#9912) Motivation Recent optimization netty#9765 introduced a bug where the native indices of the internal reused duplicate nio buffer are not properly reset prior to using it to copy data during a reallocation operation. This can result in BufferOverflowExceptions thrown during ByteBuf capacity changes. The code path in question applies only to pooled direct buffers when Unsafe is disabled or not available. Modification Ensure ByteBuffer#clear() is always called on the reused internal nio buffer prior to returning it from PooledByteBuf#internalNioBuffer() (protected method); add unit test that exposes the bug. Result Fixes netty#9911
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Motivation
Currently when use of Unsafe is disabled and an internal reallocation is performed for a direct
PooledByteBuf, a one-off temporary duplicate is made of the source and destination backing nio buffers so that the copy can be done in a threadsafe manner.The need for this can be reduced by sharing the temporary duplicate buffer that is already stored in the corresponding destination
PooledByteBufinstance.Modifications
Have
PoolArena#memoryCopy(...)take the destinationPooledByteBufinstead of the underlying mem reference and offset, and useinternalNioBuffer()to obtain/initialize a reusable duplicate of thebacking nio buffer.
Result
Fewer temporary allocations when resizing direct pooled
ByteBufs in the non-Unsafecase