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.
88 lines
3.1 KiB
Java
88 lines
3.1 KiB
Java
/*
|
|
* Copyright 2021 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.unsafe;
|
|
|
|
import io.netty.buffer.api.AllocatorControl;
|
|
import io.netty.buffer.api.Buffer;
|
|
import io.netty.buffer.api.Drop;
|
|
import io.netty.buffer.api.MemoryManager;
|
|
import io.netty.buffer.api.internal.Statics;
|
|
import io.netty.util.internal.PlatformDependent;
|
|
|
|
import java.lang.ref.Cleaner;
|
|
|
|
import static io.netty.buffer.api.internal.Statics.convert;
|
|
|
|
public class UnsafeMemoryManager implements MemoryManager {
|
|
private final boolean offheap;
|
|
|
|
public UnsafeMemoryManager(boolean offheap) {
|
|
this.offheap = offheap;
|
|
}
|
|
|
|
@Override
|
|
public Buffer allocateShared(AllocatorControl allocatorControl, long size, Drop<Buffer> drop, Cleaner cleaner) {
|
|
final Object base;
|
|
final long address;
|
|
final UnsafeMemory memory;
|
|
final int size32 = Math.toIntExact(size);
|
|
if (cleaner == null) {
|
|
cleaner = Statics.CLEANER;
|
|
}
|
|
if (offheap) {
|
|
base = null;
|
|
address = PlatformDependent.allocateMemory(size);
|
|
PlatformDependent.setMemory(address, size, (byte) 0);
|
|
memory = new UnsafeMemory(base, address, size32);
|
|
drop = new CleanerDrop(memory, drop, cleaner);
|
|
} else {
|
|
base = new byte[size32];
|
|
address = PlatformDependent.byteArrayBaseOffset();
|
|
memory = new UnsafeMemory(base, address, size32);
|
|
}
|
|
return new UnsafeBuffer(memory, 0, size32, allocatorControl, convert(drop));
|
|
}
|
|
|
|
@Override
|
|
public Buffer allocateCopyOnWritable(Buffer ownedReadOnlyBuffer) {
|
|
assert ownedReadOnlyBuffer.isOwned() && ownedReadOnlyBuffer.readOnly();
|
|
UnsafeBuffer buf = (UnsafeBuffer) ownedReadOnlyBuffer;
|
|
return new UnsafeBuffer(buf);
|
|
}
|
|
|
|
@Override
|
|
public Drop<Buffer> drop() {
|
|
// We cannot reliably drop unsafe memory. We have to rely on the cleaner to do that.
|
|
return Statics.NO_OP_DROP;
|
|
}
|
|
|
|
@Override
|
|
public Object unwrapRecoverableMemory(Buffer buf) {
|
|
return ((UnsafeBuffer) buf).recover();
|
|
}
|
|
|
|
@Override
|
|
public int capacityOfRecoverableMemory(Object memory) {
|
|
return ((UnsafeMemory) memory).size;
|
|
}
|
|
|
|
@Override
|
|
public Buffer recoverMemory(AllocatorControl allocatorControl, Object recoverableMemory, Drop<Buffer> drop) {
|
|
UnsafeMemory memory = (UnsafeMemory) recoverableMemory;
|
|
return new UnsafeBuffer(memory, 0, memory.size, allocatorControl, convert(drop));
|
|
}
|
|
}
|