2 // ========================================================================
3 // Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd.
4 // ------------------------------------------------------------------------
5 // All rights reserved. This program and the accompanying materials
6 // are made available under the terms of the Eclipse Public License v1.0
7 // and Apache License v2.0 which accompanies this distribution.
9 // The Eclipse Public License is available at
10 // http://www.eclipse.org/legal/epl-v10.html
12 // The Apache License v2.0 is available at
13 // http://www.opensource.org/licenses/apache2.0.php
15 // You may elect to redistribute this code under either of these licenses.
16 // ========================================================================
19 package org.eclipse.jetty.io;
21 import java.nio.ByteBuffer;
22 import java.util.Queue;
23 import java.util.concurrent.ConcurrentHashMap;
24 import java.util.concurrent.ConcurrentLinkedQueue;
25 import java.util.concurrent.ConcurrentMap;
26 import java.util.concurrent.atomic.AtomicInteger;
28 import org.eclipse.jetty.util.BufferUtil;
30 public class MappedByteBufferPool implements ByteBufferPool
32 private final ConcurrentMap<Integer, Queue<ByteBuffer>> directBuffers = new ConcurrentHashMap<>();
33 private final ConcurrentMap<Integer, Queue<ByteBuffer>> heapBuffers = new ConcurrentHashMap<>();
34 private final int factor;
36 public MappedByteBufferPool()
41 public MappedByteBufferPool(int factor)
47 public ByteBuffer acquire(int size, boolean direct)
49 int bucket = bucketFor(size);
50 ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct);
52 ByteBuffer result = null;
53 Queue<ByteBuffer> byteBuffers = buffers.get(bucket);
54 if (byteBuffers != null)
55 result = byteBuffers.poll();
59 int capacity = bucket * factor;
60 result = newByteBuffer(capacity, direct);
63 BufferUtil.clear(result);
67 protected ByteBuffer newByteBuffer(int capacity, boolean direct)
69 return direct ? BufferUtil.allocateDirect(capacity)
70 : BufferUtil.allocate(capacity);
74 public void release(ByteBuffer buffer)
77 return; // nothing to do
79 // validate that this buffer is from this pool
80 assert((buffer.capacity() % factor) == 0);
82 int bucket = bucketFor(buffer.capacity());
83 ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect());
85 // Avoid to create a new queue every time, just to be discarded immediately
86 Queue<ByteBuffer> byteBuffers = buffers.get(bucket);
87 if (byteBuffers == null)
89 byteBuffers = new ConcurrentLinkedQueue<>();
90 Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers);
92 byteBuffers = existing;
95 BufferUtil.clear(buffer);
96 byteBuffers.offer(buffer);
101 directBuffers.clear();
105 private int bucketFor(int size)
107 int bucket = size / factor;
108 if (size % factor > 0)
113 // Package local for testing
114 ConcurrentMap<Integer, Queue<ByteBuffer>> buffersFor(boolean direct)
116 return direct ? directBuffers : heapBuffers;
119 public static class Tagged extends MappedByteBufferPool
121 private final AtomicInteger tag = new AtomicInteger();
124 protected ByteBuffer newByteBuffer(int capacity, boolean direct)
126 ByteBuffer buffer = super.newByteBuffer(capacity + 4, direct);
127 buffer.limit(buffer.capacity());
128 buffer.putInt(tag.incrementAndGet());
129 ByteBuffer slice = buffer.slice();
130 BufferUtil.clear(slice);