DirectArena Class — netty Architecture

Source Code

buffer/src/main/java/io/netty/buffer/PoolArena.java lines 723–804

    static final class DirectArena extends PoolArena<ByteBuffer> {

        DirectArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {
            super(parent, sizeClass);
        }

        @Override
        boolean isDirect() {
            return true;
        }

        @Override
        protected PoolChunk<ByteBuffer> newChunk(int pageSize, int maxPageIdx, int pageShifts, int chunkSize) {
            if (sizeClass.directMemoryCacheAlignment == 0) {
                CleanableDirectBuffer cleanableDirectBuffer = allocateDirect(chunkSize);
                ByteBuffer memory = cleanableDirectBuffer.buffer();
                return new PoolChunk<ByteBuffer>(this, cleanableDirectBuffer, memory, memory, pageSize, pageShifts,
                        chunkSize, maxPageIdx);
            }

            CleanableDirectBuffer cleanableDirectBuffer = allocateDirect(
                    chunkSize + sizeClass.directMemoryCacheAlignment);
            final ByteBuffer base = cleanableDirectBuffer.buffer();
            final ByteBuffer memory = PlatformDependent.alignDirectBuffer(base, sizeClass.directMemoryCacheAlignment);
            return new PoolChunk<ByteBuffer>(this, cleanableDirectBuffer, base, memory, pageSize,
                    pageShifts, chunkSize, maxPageIdx);
        }

        @Override
        protected PoolChunk<ByteBuffer> newUnpooledChunk(int capacity) {
            if (sizeClass.directMemoryCacheAlignment == 0) {
                CleanableDirectBuffer cleanableDirectBuffer = allocateDirect(capacity);
                ByteBuffer memory = cleanableDirectBuffer.buffer();
                return new PoolChunk<ByteBuffer>(this, cleanableDirectBuffer, memory, memory, capacity);
            }

            CleanableDirectBuffer cleanableDirectBuffer = allocateDirect(
                    capacity + sizeClass.directMemoryCacheAlignment);
            final ByteBuffer base = cleanableDirectBuffer.buffer();
            final ByteBuffer memory = PlatformDependent.alignDirectBuffer(base, sizeClass.directMemoryCacheAlignment);
            return new PoolChunk<ByteBuffer>(this, cleanableDirectBuffer, base, memory, capacity);
        }

        private static CleanableDirectBuffer allocateDirect(int capacity) {
            return PlatformDependent.allocateDirect(capacity);
        }

        @Override
        protected void destroyChunk(PoolChunk<ByteBuffer> chunk) {
            PooledByteBufAllocator.onDeallocateChunk(chunk, !chunk.unpooled);
            chunk.cleanable.clean();
        }

        @Override
        protected PooledByteBuf<ByteBuffer> newByteBuf(int maxCapacity) {
            if (HAS_UNSAFE) {
                return PooledUnsafeDirectByteBuf.newInstance(maxCapacity);
            } else {
                return PooledDirectByteBuf.newInstance(maxCapacity);
            }
        }

        @Override
        protected void memoryCopy(ByteBuffer src, int srcOffset, PooledByteBuf<ByteBuffer> dstBuf, int length) {
            if (length == 0) {
                return;
            }

            if (HAS_UNSAFE) {
                PlatformDependent.copyMemory(
                        PlatformDependent.directBufferAddress(src) + srcOffset,
                        PlatformDependent.directBufferAddress(dstBuf.memory) + dstBuf.offset, length);
            } else {
                // We must duplicate the NIO buffers because they may be accessed by other Netty buffers.
                src = src.duplicate();
                ByteBuffer dst = dstBuf.internalNioBuffer();
                src.position(srcOffset).limit(srcOffset + length);
                dst.position(dstBuf.offset);
                dst.put(src);
            }
        }