/*
 * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package jdk.internal.jimage;

import java.lang.ref.WeakReference;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;

Implementation Note:This class needs to maintain JDK 8 source compatibility. It is used internally in the JDK to implement jimage/jrtfs access, but also compiled and delivered as part of the jrt-fs.jar to support access to the jimage file provided by the shipped JDK by tools running on JDK 8.
/** * @implNote This class needs to maintain JDK 8 source compatibility. * * It is used internally in the JDK to implement jimage/jrtfs access, * but also compiled and delivered as part of the jrt-fs.jar to support access * to the jimage file provided by the shipped JDK by tools running on JDK 8. */
class ImageBufferCache { private static final int MAX_CACHED_BUFFERS = 3; private static final int LARGE_BUFFER = 0x10000; private static final ThreadLocal<BufferReference[]> CACHE = new ThreadLocal<BufferReference[]>() { @Override protected BufferReference[] initialValue() { // 1 extra slot to simplify logic of releaseBuffer() return new BufferReference[MAX_CACHED_BUFFERS + 1]; } }; private static ByteBuffer allocateBuffer(long size) { return ByteBuffer.allocateDirect((int)((size + 0xFFF) & ~0xFFF)); } static ByteBuffer getBuffer(long size) { if (size < 0 || Integer.MAX_VALUE < size) { throw new IndexOutOfBoundsException("size"); } ByteBuffer result = null; if (size > LARGE_BUFFER) { result = allocateBuffer(size); } else { BufferReference[] cache = CACHE.get(); // buffers are ordered by decreasing capacity // cache[MAX_CACHED_BUFFERS] is always null for (int i = MAX_CACHED_BUFFERS - 1; i >= 0; i--) { BufferReference reference = cache[i]; if (reference != null) { ByteBuffer buffer = reference.get(); if (buffer != null && size <= buffer.capacity()) { cache[i] = null; result = buffer; result.rewind(); break; } } } if (result == null) { result = allocateBuffer(size); } } result.limit((int)size); return result; } static void releaseBuffer(ByteBuffer buffer) { if (buffer.capacity() > LARGE_BUFFER) { return; } BufferReference[] cache = CACHE.get(); // expunge cleared BufferRef(s) for (int i = 0; i < MAX_CACHED_BUFFERS; i++) { BufferReference reference = cache[i]; if (reference != null && reference.get() == null) { cache[i] = null; } } // insert buffer back with new BufferRef wrapping it cache[MAX_CACHED_BUFFERS] = new BufferReference(buffer); Arrays.sort(cache, DECREASING_CAPACITY_NULLS_LAST); // squeeze the smallest one out cache[MAX_CACHED_BUFFERS] = null; } private static Comparator<BufferReference> DECREASING_CAPACITY_NULLS_LAST = new Comparator<BufferReference>() { @Override public int compare(BufferReference br1, BufferReference br2) { return Integer.compare(br2 == null ? 0 : br2.capacity, br1 == null ? 0 : br1.capacity); } }; private static class BufferReference extends WeakReference<ByteBuffer> { // saved capacity so that DECREASING_CAPACITY_NULLS_LAST comparator // is stable in the presence of GC clearing the WeakReference concurrently final int capacity; BufferReference(ByteBuffer buffer) { super(buffer); capacity = buffer.capacity(); } } }