@Override public void afterPropertiesSet() throws Exception { String name = this.threadPrefix + "@" + Integer.toHexString(hashCode()); if (this.executor == null) { QueuedThreadPool threadPool = new QueuedThreadPool(); threadPool.setName(name); this.executor = threadPool; } if (this.byteBufferPool == null) { this.byteBufferPool = new MappedByteBufferPool(2048, this.executor instanceof ThreadPool.SizedThreadPool ? ((ThreadPool.SizedThreadPool) executor).getMaxThreads() / 2 : ProcessorUtils.availableProcessors() * 2); } if (this.scheduler == null) { this.scheduler = new ScheduledExecutorScheduler(name + "-scheduler", false); } if (this.executor instanceof LifeCycle) { ((LifeCycle)this.executor).start(); } this.scheduler.start(); }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = newByteBuffer(capacity, direct); } BufferUtil.clear(result); return result; }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,_newBucket); bucket.release(buffer); }
@Override public ByteBuffer newByteBuffer(int capacity, boolean direct) { ByteBuffer buffer = super.newByteBuffer(capacity + 4, direct); buffer.limit(buffer.capacity()); buffer.putInt(tag.incrementAndGet()); ByteBuffer slice = buffer.slice(); BufferUtil.clear(slice); return slice; } }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,_newBucket); bucket.release(buffer); }
@Override protected ByteBuffer newByteBuffer(int capacity, boolean direct) { ByteBuffer buffer = super.newByteBuffer(capacity + 4, direct); buffer.limit(buffer.capacity()); buffer.putInt(tag.incrementAndGet()); ByteBuffer slice = buffer.slice(); BufferUtil.clear(slice); return slice; } }
@Override public void afterPropertiesSet() throws Exception { String name = this.threadPrefix + "@" + Integer.toHexString(hashCode()); if (this.executor == null) { QueuedThreadPool threadPool = new QueuedThreadPool(); threadPool.setName(name); this.executor = threadPool; } if (this.byteBufferPool == null) { this.byteBufferPool = new MappedByteBufferPool(2048, this.executor instanceof ThreadPool.SizedThreadPool ? ((ThreadPool.SizedThreadPool) executor).getMaxThreads() / 2 : ProcessorUtils.availableProcessors() * 2); } if (this.scheduler == null) { this.scheduler = new ScheduledExecutorScheduler(name + "-scheduler", false); } if (this.executor instanceof LifeCycle) { ((LifeCycle)this.executor).start(); } this.scheduler.start(); }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,bi->new Bucket(b*_factor,_maxQueue)); bucket.release(buffer); }
@Override public ByteBuffer newByteBuffer(int capacity, boolean direct) { ByteBuffer buffer = super.newByteBuffer(capacity + 4, direct); buffer.limit(buffer.capacity()); buffer.putInt(tag.incrementAndGet()); ByteBuffer slice = buffer.slice(); BufferUtil.clear(slice); return slice; } }
public WebSocketUpgradeHandlerWrapper(ServletContextHandler context) { this(context, new MappedByteBufferPool()); }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = direct ? BufferUtil.allocateDirect(capacity) : BufferUtil.allocate(capacity); } BufferUtil.clear(result); return result; }
@Override protected ByteBuffer newByteBuffer(int capacity, boolean direct) { ByteBuffer buffer = super.newByteBuffer(capacity + 4, direct); buffer.limit(buffer.capacity()); buffer.putInt(tag.incrementAndGet()); ByteBuffer slice = buffer.slice(); BufferUtil.clear(slice); return slice; } }
/** * Entry point for {@link org.eclipse.jetty.websocket.servlet.WebSocketServletFactory.Loader} * * @param context the servlet context * @param policy the policy to use */ public WebSocketServerFactory(ServletContext context, WebSocketPolicy policy) { this(context, policy, new MappedByteBufferPool()); }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = direct ? BufferUtil.allocateDirect(capacity) : BufferUtil.allocate(capacity); } BufferUtil.clear(result); return result; }