Understanding Zero‑Copy and CompositeChannelBuffer in Netty

Zero‑copy is a technique where the CPU does not copy data between memory areas; instead, data is transferred directly between kernel space and the network, reducing CPU overhead. Wikipedia defines it as "Zero‑copy describes computer operations in which the CPU does not perform the task of copying data from one memory area to another."

In network transmission, zero‑copy avoids moving file contents from user space to kernel space, allowing the kernel to send data directly from disk buffers to the network interface, which improves overall system performance.

Non‑zero‑copy requires the data to be copied into user‑space buffers before sending, while zero‑copy bypasses this step. The article includes diagrams (omitted here) illustrating both approaches.

Netty leverages zero‑copy via Java NIO's FileChannel.transferTo() (used by sendfile()) and by wrapping multiple buffers in a virtual buffer that does not copy data. This virtual buffer is implemented by the CompositeChannelBuffer class.

CompositeChannelBuffer combines several ChannelBuffer instances into a single logical buffer. It stores references to the component buffers rather than merging their contents, thus achieving zero‑copy.

The class defines several important fields:

private int readerIndex;
private int writerIndex;
private ChannelBuffer[] components;
private int[] indices;
private int lastAccessedComponentId;

The setComponents(List<ChannelBuffer> newComponents) method initializes these fields, validates that all buffers share the same endianness, populates the components array, builds an index table ( indices) for fast lookup, and finally resets the read/write pointers with setIndex(0, capacity()):

private void setComponents(List<ChannelBuffer> newComponents) {
    assert !newComponents.isEmpty();
    // Clear the cache.
    lastAccessedComponentId = 0;
    // Build the component array.
    components = new ChannelBuffer[newComponents.size()];
    for (int i = 0; i < components.length; i++) {
        ChannelBuffer c = newComponents.get(i);
        if (c.order() != order()) {
            throw new IllegalArgumentException("All buffers must have the same endianness.");
        }
        assert c.readerIndex() == 0;
        assert c.writerIndex() == c.capacity();
        components[i] = c;
    }
    // Build the component lookup table.
    indices = new int[components.length + 1];
    indices[0] = 0;
    for (int i = 1; i <= components.length; i++) {
        indices[i] = indices[i - 1] + components[i - 1].capacity();
    }
    // Reset the indexes.
    setIndex(0, capacity());
}

Random access is provided by CompositeChannelBuffer.getByte(int index), which first determines the component buffer that contains the requested byte and then delegates the read to that component:

public byte getByte(int index) {
    int componentId = componentId(index);
    return components[componentId].getByte(index - indices[componentId]);
}

The helper method componentId(int index) locates the appropriate component using the previously stored lastAccessedComponentId as a starting point, searching to the right or left as needed. This locality‑aware search speeds up consecutive accesses that fall within the same or neighboring buffers.

private int componentId(int index) {
    int lastComponentId = lastAccessedComponentId;
    if (index >= indices[lastComponentId]) {
        if (index < indices[lastComponentId + 1]) {
            return lastComponentId;
        }
        // Search right
        for (int i = lastComponentId + 1; i < components.length; i++) {
            if (index < indices[i + 1]) {
                lastAccessedComponentId = i;
                return i;
            }
        }
    } else {
        // Search left
        for (int i = lastComponentId - 1; i >= 0; i--) {
            if (index >= indices[i]) {
                lastAccessedComponentId = i;
                return i;
            }
        }
    }
    throw new IndexOutOfBoundsException("Invalid index: " + index + ", maximum: " + indices.length);
}

By keeping only references to the underlying buffers and using these efficient lookup mechanisms, Netty achieves zero‑copy data handling, reducing memory copies and improving throughput for high‑performance network applications.

References:

http://my.oschina.net/flashsword/blog/164237

http://en.wikipedia.org/wiki/Zero-copy

http://stackoverflow.com/questions/20727615/is-nettys-zero-copy-different-from-os-level-zero-copy

http://www-old.itm.uni-luebeck.de/teaching/ws1112/vs/Uebung/GrossUebungNetty/VS-WS1112-xx-Zero-Copy_Event-Driven_Servers_with_Netty.pdf?lang=de