51cc1e7cf4
The const buffers of the various implementations are now able to share the underlying memory. At least until they are forced not to. Const buffers will behave ust like normal buffers, except they start out as read-only. When they are made writable, or sliced, then they will allocate their own independent copy of the memory. That way, const buffers can have their contents changed, and behave just like normal buffers. The const-ness is a pure optimisation that should not have any externally observable behaviour.
58 lines
2.0 KiB
Java
58 lines
2.0 KiB
Java
/*
|
|
* Copyright 2020 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:
|
|
*
|
|
* https://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.api;
|
|
|
|
import io.netty.buffer.api.internal.Statics;
|
|
|
|
import java.lang.ref.Cleaner;
|
|
import java.util.function.Supplier;
|
|
|
|
import static io.netty.buffer.api.internal.Statics.NO_OP_DROP;
|
|
|
|
class ManagedBufferAllocator implements BufferAllocator, AllocatorControl {
|
|
private final MemoryManager manager;
|
|
|
|
ManagedBufferAllocator(MemoryManager manager) {
|
|
this.manager = manager;
|
|
}
|
|
|
|
@Override
|
|
public Buffer allocate(int size) {
|
|
BufferAllocator.checkSize(size);
|
|
return manager.allocateShared(this, size, manager.drop(), Statics.CLEANER);
|
|
}
|
|
|
|
@Override
|
|
public Supplier<Buffer> constBufferSupplier(byte[] bytes) {
|
|
Buffer constantBuffer = manager.allocateShared(this, bytes.length, manager.drop(), Statics.CLEANER);
|
|
constantBuffer.writeBytes(bytes).readOnly(true);
|
|
return () -> manager.allocateCopyOnWritable(constantBuffer);
|
|
}
|
|
|
|
@Override
|
|
public Object allocateUntethered(Buffer originator, int size) {
|
|
BufferAllocator.checkSize(size);
|
|
var buf = manager.allocateShared(this, size, NO_OP_DROP, Statics.CLEANER);
|
|
return manager.unwrapRecoverableMemory(buf);
|
|
}
|
|
|
|
@Override
|
|
public void recoverMemory(Object memory) {
|
|
// Free the recovered memory.
|
|
manager.recoverMemory(this, memory, manager.drop()).close();
|
|
}
|
|
}
|