How to use org.glassfish.grizzly.memory

@Override
public void write(int b) throws IOException {
  final byte[] buffer = new byte[1];
  buffer[0] = (byte) b;
  delegate.feed(Buffers.wrap(MemoryManager.DEFAULT_MEMORY_MANAGER, buffer), false);
}

@Override
public NextAction handleWrite(FilterChainContext context) throws IOException {
  Connection<?> connection = context.getConnection();
  GrizzlyChannel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
  try {
    ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer(1024); // Do not need to close
    Object msg = context.getMessage();
    codec.encode(channel, channelBuffer, msg);
    GrizzlyChannel.removeChannelIfDisconnected(connection);
    Buffer buffer = connection.getTransport().getMemoryManager().allocate(channelBuffer.readableBytes());
    buffer.put(channelBuffer.toByteBuffer());
    buffer.flip();
    buffer.allowBufferDispose(true);
    context.setMessage(buffer);
  } finally {
    GrizzlyChannel.removeChannelIfDisconnected(connection);
  }
  return context.getInvokeAction();
}

protected final void releaseHeapBuffer(final HeapBuffer heapBuffer) {
  final ThreadLocalPool<HeapBuffer> memoryPool = getHeapBufferThreadLocalPool();
  if (memoryPool != null) {
    if (memoryPool.release(heapBuffer.clear())) {
      ProbeNotifier.notifyBufferReleasedToPool(monitoringConfig,
          heapBuffer.capacity());
    }
  }
}

Buffer buffer = mm.allocate(512);
final byte[] b = new byte[512];
int read;
    buffer = mm.reallocate(buffer, buffer.capacity() + 512);

public Buffer allocate() {
  final PoolSlice slice = getSlice();
  PoolBuffer b = slice.poll();
  if (b == null) {
    b = slice.allocate();
  }
  
  return b.prepare();
}

private void reallocatePoolBuffer() {
  final byte[] heap = new byte[maxBufferSize];
  ProbeNotifier.notifyBufferAllocated(monitoringConfig, maxBufferSize);
  final HeapBufferThreadLocalPool threadLocalCache =
      getHeapBufferThreadLocalPool();
  if (threadLocalCache != null) {
    threadLocalCache.reset(heap, 0, maxBufferSize);
  }
}

public GrizzlyResponse(final HttpResponsePacket httpResponsePacket,
            final HttpResponseStatus status,
            final HttpResponseHeaders headers,
            final List<HttpResponseBodyPart> bodyParts) {
  super(status, headers, bodyParts);
  this.httpResponsePacket = httpResponsePacket;
  
  if (isNonEmpty(bodyParts)) {
    if (bodyParts.size() == 1) {
      responseBody = ((GrizzlyResponseBodyPart) bodyParts.get(0)).getBodyBuffer();
    } else {
      final Buffer firstBuffer = ((GrizzlyResponseBodyPart) bodyParts.get(0)).getBodyBuffer();
      final MemoryManager mm = httpResponsePacket.getRequest().getConnection().getMemoryManager();
      Buffer constructedBodyBuffer = firstBuffer;
      for (int i = 1, len = bodyParts.size(); i < len; i++) {
        constructedBodyBuffer =
            Buffers.appendBuffers(mm,
                constructedBodyBuffer,
                ((GrizzlyResponseBodyPart) bodyParts.get(i)).getBodyBuffer());
      }
      responseBody = constructedBodyBuffer;
    }
  } else {
    responseBody = Buffers.EMPTY_BUFFER;
  }
}

protected final void releaseHeapBuffer(final HeapBuffer heapBuffer) {
  final ThreadLocalPool<HeapBuffer> memoryPool = getHeapBufferThreadLocalPool();
  if (memoryPool != null) {
    if (memoryPool.release(heapBuffer.clear())) {
      ProbeNotifier.notifyBufferReleasedToPool(monitoringConfig,
          heapBuffer.capacity());
    }
  }
}

@Override
public void write(byte[] b, int off, int len) throws IOException {
  delegate.feed(Buffers.wrap(MemoryManager.DEFAULT_MEMORY_MANAGER, b, off, len), false);
}

@Override
public NextAction handleWrite(FilterChainContext context) throws IOException {
  Connection<?> connection = context.getConnection();
  GrizzlyChannel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
  try {
    ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer(1024); // Do not need to close
    Object msg = context.getMessage();
    codec.encode(channel, channelBuffer, msg);
    GrizzlyChannel.removeChannelIfDisconnected(connection);
    Buffer buffer = connection.getTransport().getMemoryManager().allocate(channelBuffer.readableBytes());
    buffer.put(channelBuffer.toByteBuffer());
    buffer.flip();
    buffer.allowBufferDispose(true);
    context.setMessage(buffer);
  } finally {
    GrizzlyChannel.removeChannelIfDisconnected(connection);
  }
  return context.getInvokeAction();
}

protected final void releaseHeapBuffer(final HeapBuffer heapBuffer) {
  final ThreadLocalPool<HeapBuffer> memoryPool = getHeapBufferThreadLocalPool();
  if (memoryPool != null) {
    if (memoryPool.release(heapBuffer.clear())) {
      ProbeNotifier.notifyBufferReleasedToPool(monitoringConfig,
          heapBuffer.capacity());
    }
  }
}

@Override
public void write(byte[] b) throws IOException {
  delegate.feed(Buffers.wrap(MemoryManager.DEFAULT_MEMORY_MANAGER, b), false);
}

boolean last = false;
while (!last) {
  Buffer buffer = mm.allocate(PayloadGenerator.MAX_CHUNK_SIZE);
  buffer.allowBufferDispose(true);
  final long readBytes = bodyLocal.read(buffer.toByteBuffer());

protected final void releaseHeapBuffer(final HeapBuffer heapBuffer) {
  final ThreadLocalPool<HeapBuffer> memoryPool = getHeapBufferThreadLocalPool();
  if (memoryPool != null) {
    if (memoryPool.release(heapBuffer.clear())) {
      ProbeNotifier.notifyBufferReleasedToPool(monitoringConfig,
          heapBuffer.capacity());
    }
  }
}

final byte[] data = sb.toString().getBytes(charset);
final MemoryManager mm = ctx.getMemoryManager();
final Buffer gBuffer = Buffers.wrap(mm, data);
final HttpContent content = requestPacket.httpContentBuilder()
    .content(gBuffer)

Buffer buffer = mm.allocate(MAX_CHUNK_SIZE);
buffer.allowBufferDispose(true);

protected final void releaseHeapBuffer(final HeapBuffer heapBuffer) {
  final ThreadLocalPool<HeapBuffer> memoryPool = getHeapBufferThreadLocalPool();
  if (memoryPool != null) {
    if (memoryPool.release(heapBuffer.clear())) {
      ProbeNotifier.notifyBufferReleasedToPool(monitoringConfig,
          heapBuffer.capacity());
    }
  }
}

@SuppressWarnings({"unchecked"})
public boolean generate(final FilterChainContext ctx,
           final Request request,
           final HttpRequestPacket requestPacket)
throws IOException {
  String charset = request.getBodyEncoding();
  if (charset == null) {
    charset = Charsets.ASCII_CHARSET.name();
  }
  final byte[] data = request.getStringData().getBytes(charset);
  final MemoryManager mm = ctx.getMemoryManager();
  final Buffer gBuffer = Buffers.wrap(mm, data);
  if (requestPacket.getContentLength() == -1) {
    requestPacket.setContentLengthLong(data.length);
  }
  final HttpContent content = requestPacket.httpContentBuilder()
      .content(gBuffer)
      .last(true)
      .build();
  ctx.write(content, ((!requestPacket.isCommitted())
      ? ctx.getTransportContext().getCompletionHandler()
      : null));
  return true;
}

@SuppressWarnings({"unchecked"})
public boolean generate(final FilterChainContext ctx,
           final Request request,
           final HttpRequestPacket requestPacket)
throws IOException {
  final MemoryManager mm = ctx.getMemoryManager();
  final byte[] data = request.getByteData();
  final Buffer gBuffer = Buffers.wrap(mm, data);
  if (requestPacket.getContentLength() == -1) {
    requestPacket.setContentLengthLong(data.length);
  }
  final HttpContent content = requestPacket.httpContentBuilder()
      .content(gBuffer)
      .last(true)
      .build();
  
  ctx.write(content, ((!requestPacket.isCommitted())
      ? ctx.getTransportContext().getCompletionHandler()
      : null));
  return true;
}

b = Buffers.wrap(mm, buf, 0, read);