Revert "Add PooledSlicedByteBuf and PooledDuplicatedByteBuf"

Motivation:
Currently the "derived" buffer will only ever be recycled if the release call is made on the "derived" object, and the "wrapped" buffer ends up being "fully released" (aka refcount goes to 0). From my experience this is not the common use case and thus the "derived" buffers will not be recycled.

Modifications:
- revert https://github.com/netty/netty/pull/3788

Result:
Less complexity, and less code to create new objects in majority of cases.
This commit is contained in:
Scott Mitchell 2015-08-26 13:08:54 -07:00
parent 5b4a96a7ac
commit 33001e84ff
6 changed files with 8 additions and 162 deletions

View File

@ -47,20 +47,12 @@ public abstract class AbstractDerivedByteBuf extends AbstractByteBuf {
@Override
public final boolean release() {
if (unwrap().release()) {
deallocate();
return true;
}
return false;
return unwrap().release();
}
@Override
public final boolean release(int decrement) {
if (unwrap().release(decrement)) {
deallocate();
return true;
}
return false;
return unwrap().release(decrement);
}
@Override
@ -72,9 +64,4 @@ public abstract class AbstractDerivedByteBuf extends AbstractByteBuf {
public ByteBuffer nioBuffer(int index, int length) {
return unwrap().nioBuffer(index, length);
}
/**
* Called when the wrapped {@link ByteBuf} was released due calling of {@link #release()} or {@link #release(int)}.
*/
protected void deallocate() { }
}

View File

@ -31,19 +31,11 @@ import java.nio.channels.ScatteringByteChannel;
*/
public class DuplicatedByteBuf extends AbstractDerivedByteBuf {
private ByteBuf buffer;
private final ByteBuf buffer;
public DuplicatedByteBuf(ByteBuf buffer) {
super(buffer.maxCapacity());
init(buffer);
}
DuplicatedByteBuf(int maxCapacity) {
super(maxCapacity);
}
final void init(ByteBuf buffer) {
maxCapacity(buffer.maxCapacity());
if (buffer instanceof DuplicatedByteBuf) {
this.buffer = ((DuplicatedByteBuf) buffer).buffer;
} else {
@ -51,8 +43,6 @@ public class DuplicatedByteBuf extends AbstractDerivedByteBuf {
}
setIndex(buffer.readerIndex(), buffer.writerIndex());
markReaderIndex();
markWriterIndex();
}
@Override

View File

@ -68,16 +68,6 @@ abstract class PooledByteBuf<T> extends AbstractReferenceCountedByteBuf {
cache = null;
}
@Override
public ByteBuf slice(int index, int length) {
return PooledSlicedByteBuf.newInstance(this, index, length);
}
@Override
public ByteBuf duplicate() {
return PooledDuplicatedByteBuf.newInstance(this);
}
@Override
public final int capacity() {
return length;

View File

@ -1,56 +0,0 @@
/*
* Copyright 2015 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer;
import io.netty.util.Recycler;
final class PooledDuplicatedByteBuf extends DuplicatedByteBuf {
private static final Recycler<PooledDuplicatedByteBuf> RECYCLER = new Recycler<PooledDuplicatedByteBuf>() {
@Override
protected PooledDuplicatedByteBuf newObject(Handle handle) {
return new PooledDuplicatedByteBuf(handle);
}
};
static PooledDuplicatedByteBuf newInstance(ByteBuf buffer) {
PooledDuplicatedByteBuf buf = RECYCLER.get();
buf.init(buffer);
return buf;
}
private final Recycler.Handle recyclerHandle;
private PooledDuplicatedByteBuf(Recycler.Handle recyclerHandle) {
super(0);
this.recyclerHandle = recyclerHandle;
}
@Override
public ByteBuf slice(int index, int length) {
return PooledSlicedByteBuf.newInstance(this, index, length);
}
@Override
public ByteBuf duplicate() {
return newInstance(this);
}
@Override
protected void deallocate() {
RECYCLER.recycle(this, recyclerHandle);
}
}

View File

@ -1,56 +0,0 @@
/*
* Copyright 2015 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer;
import io.netty.util.Recycler;
final class PooledSlicedByteBuf extends SlicedByteBuf {
private static final Recycler<PooledSlicedByteBuf> RECYCLER = new Recycler<PooledSlicedByteBuf>() {
@Override
protected PooledSlicedByteBuf newObject(Handle handle) {
return new PooledSlicedByteBuf(handle);
}
};
static PooledSlicedByteBuf newInstance(ByteBuf buffer, int index, int length) {
PooledSlicedByteBuf buf = RECYCLER.get();
buf.init(buffer, index, length);
return buf;
}
private final Recycler.Handle recyclerHandle;
private PooledSlicedByteBuf(Recycler.Handle recyclerHandle) {
super(0);
this.recyclerHandle = recyclerHandle;
}
@Override
public ByteBuf slice(int index, int length) {
return newInstance(this, index, length);
}
@Override
public ByteBuf duplicate() {
return PooledDuplicatedByteBuf.newInstance(this);
}
@Override
protected void deallocate() {
RECYCLER.recycle(this, recyclerHandle);
}
}

View File

@ -32,20 +32,12 @@ import java.nio.channels.ScatteringByteChannel;
*/
public class SlicedByteBuf extends AbstractDerivedByteBuf {
private ByteBuf buffer;
private int adjustment;
private int length;
private final ByteBuf buffer;
private final int adjustment;
private final int length;
public SlicedByteBuf(ByteBuf buffer, int index, int length) {
super(length);
init(buffer, index, length);
}
SlicedByteBuf(int length) {
super(length);
}
final void init(ByteBuf buffer, int index, int length) {
if (index < 0 || index > buffer.capacity() - length) {
throw new IndexOutOfBoundsException(buffer + ".slice(" + index + ", " + length + ')');
}
@ -61,9 +53,8 @@ public class SlicedByteBuf extends AbstractDerivedByteBuf {
adjustment = index;
}
this.length = length;
maxCapacity(length);
setIndex(0, length);
discardMarks();
writerIndex(length);
}
@Override