text: /*
   * Copyright (c) 2008, 2009, 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 sun.nio.fs;
  
  import jdk.internal.misc.TerminatingThreadLocal;
  import jdk.internal.misc.Unsafe;
  
  /**
   * Factory for native buffers.
   */
  
  class NativeBuffers {
      private NativeBuffers() { }
  
      private static final Unsafe unsafe = Unsafe.getUnsafe();
  
      private static final int TEMP_BUF_POOL_SIZE = 3;
      private static ThreadLocal<NativeBuffer[]> threadLocal = new TerminatingThreadLocal<>() {
          @Override
          protected void threadTerminated(NativeBuffer[] buffers) {
              // threadLocal may be initialized but with initialValue of null
              if (buffers != null) {
                  for (int i = 0; i < TEMP_BUF_POOL_SIZE; i++) {
                      NativeBuffer buffer = buffers[i];
                      if (buffer != null) {
                          buffer.free();
                          buffers[i] = null;
                      }
                  }
              }
          }
      };
  
      /**
       * Allocates a native buffer, of at least the given size, from the heap.
       */
      static NativeBuffer allocNativeBuffer(int size) {
          // Make a new one of at least 2k
          if (size < 2048) size = 2048;
          return new NativeBuffer(size);
      }
  
      /**
       * Returns a native buffer, of at least the given size, from the thread
       * local cache.
       */
      static NativeBuffer getNativeBufferFromCache(int size) {
          // return from cache if possible
          NativeBuffer[] buffers = threadLocal.get();
          if (buffers != null) {
              for (int i=0; i<TEMP_BUF_POOL_SIZE; i++) {
                  NativeBuffer buffer = buffers[i];
                  if (buffer != null && buffer.size() >= size) {
                      buffers[i] = null;
                      return buffer;
                  }
              }
          }
          return null;
      }
  
      /**
       * Returns a native buffer, of at least the given size. The native buffer
       * is taken from the thread local cache if possible; otherwise it is
       * allocated from the heap.
       */
      static NativeBuffer getNativeBuffer(int size) {
          NativeBuffer buffer = getNativeBufferFromCache(size);
          if (buffer != null) {
              buffer.setOwner(null);
              return buffer;
          } else {
              return allocNativeBuffer(size);
          }
      }
  
      /**
       * Releases the given buffer. If there is space in the thread local cache
       * then the buffer goes into the cache; otherwise the memory is deallocated.
       */
      static void releaseNativeBuffer(NativeBuffer buffer) {
          // create cache if it doesn't exist
          NativeBuffer[] buffers = threadLocal.get();
          if (buffers == null) {
              buffers = new NativeBuffer[TEMP_BUF_POOL_SIZE];
              buffers[0] = buffer;
              threadLocal.set(buffers);
              return;
          }
          // Put it in an empty slot if such exists
          for (int i=0; i<TEMP_BUF_POOL_SIZE; i++) {
              if (buffers[i] == null) {
                  buffers[i] = buffer;
                  return;
              }
          }
          // Otherwise replace a smaller one in the cache if such exists
          for (int i=0; i<TEMP_BUF_POOL_SIZE; i++) {
              NativeBuffer existing = buffers[i];
              if (existing.size() < buffer.size()) {
                  existing.free();
                  buffers[i] = buffer;
                  return;
              }
          }
  
          // free it
          buffer.free();
      }
  
      /**
       * Copies a byte array and zero terminator into a given native buffer.
       */
      static void copyCStringToNativeBuffer(byte[] cstr, NativeBuffer buffer) {
          long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
          long len = cstr.length;
          assert buffer.size() >= (len + 1);
          unsafe.copyMemory(cstr, offset, null, buffer.address(), len);
          unsafe.putByte(buffer.address() + len, (byte)0);
      }
  
      /**
       * Copies a byte array and zero terminator into a native buffer, returning
       * the buffer.
       */
      static NativeBuffer asNativeBuffer(byte[] cstr) {
          NativeBuffer buffer = getNativeBuffer(cstr.length+1);
          copyCStringToNativeBuffer(cstr, buffer);
          return buffer;
      }
  }
  