jdk/src/java.base/share/classes/sun/nio/ch/Util.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2000, 2013, 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.ch;

 import java.lang.reflect.*;
 import java.io.FileDescriptor;
 import java.nio.ByteBuffer;
 import java.nio.MappedByteBuffer;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.*;
 import jdk.internal.misc.Unsafe;
 import sun.misc.Cleaner;
 import sun.security.action.GetPropertyAction;


 public class Util {

     // -- Caches --

     // The number of temp buffers in our pool
     private static final int TEMP_BUF_POOL_SIZE = IOUtil.IOV_MAX;

     // Per-thread cache of temporary direct buffers
     private static ThreadLocal<BufferCache> bufferCache =
         new ThreadLocal<BufferCache>()
     {
         @Override
         protected BufferCache initialValue() {
             return new BufferCache();
         }
     };

     /**
      * A simple cache of direct buffers.
      */
     private static class BufferCache {
         // the array of buffers
         private ByteBuffer[] buffers;

         // the number of buffers in the cache
         private int count;

         // the index of the first valid buffer (undefined if count == 0)
         private int start;

         private int next(int i) {
             return (i + 1) % TEMP_BUF_POOL_SIZE;
         }

         BufferCache() {
             buffers = new ByteBuffer[TEMP_BUF_POOL_SIZE];
         }

         /**
          * Removes and returns a buffer from the cache of at least the given
          * size (or null if no suitable buffer is found).
          */
         ByteBuffer get(int size) {
             if (count == 0)
                 return null;  // cache is empty

             ByteBuffer[] buffers = this.buffers;

             // search for suitable buffer (often the first buffer will do)
             ByteBuffer buf = buffers[start];
             if (buf.capacity() < size) {
                 buf = null;
                 int i = start;
                 while ((i = next(i)) != start) {
                     ByteBuffer bb = buffers[i];
                     if (bb == null)
                         break;
                     if (bb.capacity() >= size) {
                         buf = bb;
                         break;
                     }
                 }
                 if (buf == null)
                     return null;
                 // move first element to here to avoid re-packing
                 buffers[i] = buffers[start];
             }

             // remove first element
             buffers[start] = null;
             start = next(start);
             count--;

             // prepare the buffer and return it
             buf.rewind();
             buf.limit(size);
             return buf;
         }

         boolean offerFirst(ByteBuffer buf) {
             if (count >= TEMP_BUF_POOL_SIZE) {
                 return false;
             } else {
                 start = (start + TEMP_BUF_POOL_SIZE - 1) % TEMP_BUF_POOL_SIZE;
                 buffers[start] = buf;
                 count++;
                 return true;
             }
         }

         boolean offerLast(ByteBuffer buf) {
             if (count >= TEMP_BUF_POOL_SIZE) {
                 return false;
             } else {
                 int next = (start + count) % TEMP_BUF_POOL_SIZE;
                 buffers[next] = buf;
                 count++;
                 return true;
             }
         }

         boolean isEmpty() {
             return count == 0;
         }

         ByteBuffer removeFirst() {
             assert count > 0;
             ByteBuffer buf = buffers[start];
             buffers[start] = null;
             start = next(start);
             count--;
             return buf;
         }
     }

     /**
      * Returns a temporary buffer of at least the given size
      */
     public static ByteBuffer getTemporaryDirectBuffer(int size) {
         BufferCache cache = bufferCache.get();
         ByteBuffer buf = cache.get(size);
         if (buf != null) {
             return buf;
         } else {
             // No suitable buffer in the cache so we need to allocate a new
             // one. To avoid the cache growing then we remove the first
             // buffer from the cache and free it.
             if (!cache.isEmpty()) {
                 buf = cache.removeFirst();
                 free(buf);
             }
             return ByteBuffer.allocateDirect(size);
         }
     }

     /**
      * Releases a temporary buffer by returning to the cache or freeing it.
      */
     public static void releaseTemporaryDirectBuffer(ByteBuffer buf) {
         offerFirstTemporaryDirectBuffer(buf);
     }

     /**
      * Releases a temporary buffer by returning to the cache or freeing it. If
      * returning to the cache then insert it at the start so that it is
      * likely to be returned by a subsequent call to getTemporaryDirectBuffer.
      */
     static void offerFirstTemporaryDirectBuffer(ByteBuffer buf) {
         assert buf != null;
         BufferCache cache = bufferCache.get();
         if (!cache.offerFirst(buf)) {
             // cache is full
             free(buf);
         }
     }

     /**
      * Releases a temporary buffer by returning to the cache or freeing it. If
      * returning to the cache then insert it at the end. This makes it
      * suitable for scatter/gather operations where the buffers are returned to
      * cache in same order that they were obtained.
      */
     static void offerLastTemporaryDirectBuffer(ByteBuffer buf) {
         assert buf != null;
         BufferCache cache = bufferCache.get();
         if (!cache.offerLast(buf)) {
             // cache is full
             free(buf);
         }
     }

     /**
      * Frees the memory for the given direct buffer
      */
     private static void free(ByteBuffer buf) {
         ((DirectBuffer)buf).cleaner().clean();
     }


     // -- Random stuff --

     static ByteBuffer[] subsequence(ByteBuffer[] bs, int offset, int length) {
         if ((offset == 0) && (length == bs.length))
             return bs;
         int n = length;
         ByteBuffer[] bs2 = new ByteBuffer[n];
         for (int i = 0; i < n; i++)
             bs2[i] = bs[offset + i];
         return bs2;
     }

     static <E> Set<E> ungrowableSet(final Set<E> s) {
         return new Set<E>() {

                 public int size()                 { return s.size(); }
                 public boolean isEmpty()          { return s.isEmpty(); }
                 public boolean contains(Object o) { return s.contains(o); }
                 public Object[] toArray()         { return s.toArray(); }
                 public <T> T[] toArray(T[] a)     { return s.toArray(a); }
                 public String toString()          { return s.toString(); }
                 public Iterator<E> iterator()     { return s.iterator(); }
                 public boolean equals(Object o)   { return s.equals(o); }
                 public int hashCode()             { return s.hashCode(); }
                 public void clear()               { s.clear(); }
                 public boolean remove(Object o)   { return s.remove(o); }

                 public boolean containsAll(Collection<?> coll) {
                     return s.containsAll(coll);
                 }
                 public boolean removeAll(Collection<?> coll) {
                     return s.removeAll(coll);
                 }
                 public boolean retainAll(Collection<?> coll) {
                     return s.retainAll(coll);
                 }

                 public boolean add(E o){
                     throw new UnsupportedOperationException();
                 }
                 public boolean addAll(Collection<? extends E> coll) {
                     throw new UnsupportedOperationException();
                 }

         };
     }


     // -- Unsafe access --

     private static Unsafe unsafe = Unsafe.getUnsafe();

     private static byte _get(long a) {
         return unsafe.getByte(a);
     }

     private static void _put(long a, byte b) {
         unsafe.putByte(a, b);
     }

     static void erase(ByteBuffer bb) {
         unsafe.setMemory(((DirectBuffer)bb).address(), bb.capacity(), (byte)0);
     }

     static Unsafe unsafe() {
         return unsafe;
     }

     private static int pageSize = -1;

     static int pageSize() {
         if (pageSize == -1)
             pageSize = unsafe().pageSize();
         return pageSize;
     }

     private static volatile Constructor<?> directByteBufferConstructor;

     private static void initDBBConstructor() {
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
                 public Void run() {
                     try {
                         Class<?> cl = Class.forName("java.nio.DirectByteBuffer");
                         Constructor<?> ctor = cl.getDeclaredConstructor(
                             new Class<?>[] { int.class,
                                              long.class,
                                              FileDescriptor.class,
                                              Runnable.class });
                         ctor.setAccessible(true);
                         directByteBufferConstructor = ctor;
                     } catch (ClassNotFoundException   |
                              NoSuchMethodException    |
                              IllegalArgumentException |
                              ClassCastException x) {
                         throw new InternalError(x);
                     }
                     return null;
                 }});
     }

     static MappedByteBuffer newMappedByteBuffer(int size, long addr,
                                                 FileDescriptor fd,
                                                 Runnable unmapper)
     {
         MappedByteBuffer dbb;
         if (directByteBufferConstructor == null)
             initDBBConstructor();
         try {
             dbb = (MappedByteBuffer)directByteBufferConstructor.newInstance(
               new Object[] { size,
                              addr,
                              fd,
                              unmapper });
         } catch (InstantiationException |
                  IllegalAccessException |
                  InvocationTargetException e) {
             throw new InternalError(e);
         }
         return dbb;
     }

     private static volatile Constructor<?> directByteBufferRConstructor;

     private static void initDBBRConstructor() {
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
                 public Void run() {
                     try {
                         Class<?> cl = Class.forName("java.nio.DirectByteBufferR");
                         Constructor<?> ctor = cl.getDeclaredConstructor(
                             new Class<?>[] { int.class,
                                              long.class,
                                              FileDescriptor.class,
                                              Runnable.class });
                         ctor.setAccessible(true);
                         directByteBufferRConstructor = ctor;
                     } catch (ClassNotFoundException |
                              NoSuchMethodException |
                              IllegalArgumentException |
                              ClassCastException x) {
                         throw new InternalError(x);
                     }
                     return null;
                 }});
     }

     static MappedByteBuffer newMappedByteBufferR(int size, long addr,
                                                  FileDescriptor fd,
                                                  Runnable unmapper)
     {
         MappedByteBuffer dbb;
         if (directByteBufferRConstructor == null)
             initDBBRConstructor();
         try {
             dbb = (MappedByteBuffer)directByteBufferRConstructor.newInstance(
               new Object[] { size,
                              addr,
                              fd,
                              unmapper });
         } catch (InstantiationException |
                  IllegalAccessException |
                  InvocationTargetException e) {
             throw new InternalError(e);
         }
         return dbb;
     }


     // -- Bug compatibility --

     private static volatile String bugLevel;

     static boolean atBugLevel(String bl) {              // package-private
         if (bugLevel == null) {
             if (!sun.misc.VM.isBooted())
                 return false;
             String value = AccessController.doPrivileged(
                 new GetPropertyAction("sun.nio.ch.bugLevel"));
             bugLevel = (value != null) ? value : "";
         }
         return bugLevel.equals(bl);
     }

 }
	/*
	* Copyright (c) 2000, 2013, 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.ch;

	import java.lang.reflect.*;
	import java.io.FileDescriptor;
	import java.nio.ByteBuffer;
	import java.nio.MappedByteBuffer;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.*;
	import jdk.internal.misc.Unsafe;
	import sun.misc.Cleaner;
	import sun.security.action.GetPropertyAction;


	public class Util {

	// -- Caches --

	// The number of temp buffers in our pool
	private static final int TEMP_BUF_POOL_SIZE = IOUtil.IOV_MAX;

	// Per-thread cache of temporary direct buffers
	private static ThreadLocal<BufferCache> bufferCache =
	new ThreadLocal<BufferCache>()
	{
	@Override
	protected BufferCache initialValue() {
	return new BufferCache();
	}
	};

	/**
	* A simple cache of direct buffers.
	*/
	private static class BufferCache {
	// the array of buffers
	private ByteBuffer[] buffers;

	// the number of buffers in the cache
	private int count;

	// the index of the first valid buffer (undefined if count == 0)
	private int start;

	private int next(int i) {
	return (i + 1) % TEMP_BUF_POOL_SIZE;
	}

	BufferCache() {
	buffers = new ByteBuffer[TEMP_BUF_POOL_SIZE];
	}

	/**
	* Removes and returns a buffer from the cache of at least the given
	* size (or null if no suitable buffer is found).
	*/
	ByteBuffer get(int size) {
	if (count == 0)
	return null; // cache is empty

	ByteBuffer[] buffers = this.buffers;

	// search for suitable buffer (often the first buffer will do)
	ByteBuffer buf = buffers[start];
	if (buf.capacity() < size) {
	buf = null;
	int i = start;
	while ((i = next(i)) != start) {
	ByteBuffer bb = buffers[i];
	if (bb == null)
	break;
	if (bb.capacity() >= size) {
	buf = bb;
	break;
	}
	}
	if (buf == null)
	return null;
	// move first element to here to avoid re-packing
	buffers[i] = buffers[start];
	}

	// remove first element
	buffers[start] = null;
	start = next(start);
	count--;

	// prepare the buffer and return it
	buf.rewind();
	buf.limit(size);
	return buf;
	}

	boolean offerFirst(ByteBuffer buf) {
	if (count >= TEMP_BUF_POOL_SIZE) {
	return false;
	} else {
	start = (start + TEMP_BUF_POOL_SIZE - 1) % TEMP_BUF_POOL_SIZE;
	buffers[start] = buf;
	count++;
	return true;
	}
	}

	boolean offerLast(ByteBuffer buf) {
	if (count >= TEMP_BUF_POOL_SIZE) {
	return false;
	} else {
	int next = (start + count) % TEMP_BUF_POOL_SIZE;
	buffers[next] = buf;
	count++;
	return true;
	}
	}

	boolean isEmpty() {
	return count == 0;
	}

	ByteBuffer removeFirst() {
	assert count > 0;
	ByteBuffer buf = buffers[start];
	buffers[start] = null;
	start = next(start);
	count--;
	return buf;
	}
	}

	/**
	* Returns a temporary buffer of at least the given size
	*/
	public static ByteBuffer getTemporaryDirectBuffer(int size) {
	BufferCache cache = bufferCache.get();
	ByteBuffer buf = cache.get(size);
	if (buf != null) {
	return buf;
	} else {
	// No suitable buffer in the cache so we need to allocate a new
	// one. To avoid the cache growing then we remove the first
	// buffer from the cache and free it.
	if (!cache.isEmpty()) {
	buf = cache.removeFirst();
	free(buf);
	}
	return ByteBuffer.allocateDirect(size);
	}
	}

	/**
	* Releases a temporary buffer by returning to the cache or freeing it.
	*/
	public static void releaseTemporaryDirectBuffer(ByteBuffer buf) {
	offerFirstTemporaryDirectBuffer(buf);
	}

	/**
	* Releases a temporary buffer by returning to the cache or freeing it. If
	* returning to the cache then insert it at the start so that it is
	* likely to be returned by a subsequent call to getTemporaryDirectBuffer.
	*/
	static void offerFirstTemporaryDirectBuffer(ByteBuffer buf) {
	assert buf != null;
	BufferCache cache = bufferCache.get();
	if (!cache.offerFirst(buf)) {
	// cache is full
	free(buf);
	}
	}

	/**
	* Releases a temporary buffer by returning to the cache or freeing it. If
	* returning to the cache then insert it at the end. This makes it
	* suitable for scatter/gather operations where the buffers are returned to
	* cache in same order that they were obtained.
	*/
	static void offerLastTemporaryDirectBuffer(ByteBuffer buf) {
	assert buf != null;
	BufferCache cache = bufferCache.get();
	if (!cache.offerLast(buf)) {
	// cache is full
	free(buf);
	}
	}

	/**
	* Frees the memory for the given direct buffer
	*/
	private static void free(ByteBuffer buf) {
	((DirectBuffer)buf).cleaner().clean();
	}


	// -- Random stuff --

	static ByteBuffer[] subsequence(ByteBuffer[] bs, int offset, int length) {
	if ((offset == 0) && (length == bs.length))
	return bs;
	int n = length;
	ByteBuffer[] bs2 = new ByteBuffer[n];
	for (int i = 0; i < n; i++)
	bs2[i] = bs[offset + i];
	return bs2;
	}

	static <E> Set<E> ungrowableSet(final Set<E> s) {
	return new Set<E>() {

	public int size() { return s.size(); }
	public boolean isEmpty() { return s.isEmpty(); }
	public boolean contains(Object o) { return s.contains(o); }
	public Object[] toArray() { return s.toArray(); }
	public <T> T[] toArray(T[] a) { return s.toArray(a); }
	public String toString() { return s.toString(); }
	public Iterator<E> iterator() { return s.iterator(); }
	public boolean equals(Object o) { return s.equals(o); }
	public int hashCode() { return s.hashCode(); }
	public void clear() { s.clear(); }
	public boolean remove(Object o) { return s.remove(o); }

	public boolean containsAll(Collection<?> coll) {
	return s.containsAll(coll);
	}
	public boolean removeAll(Collection<?> coll) {
	return s.removeAll(coll);
	}
	public boolean retainAll(Collection<?> coll) {
	return s.retainAll(coll);
	}

	public boolean add(E o){
	throw new UnsupportedOperationException();
	}
	public boolean addAll(Collection<? extends E> coll) {
	throw new UnsupportedOperationException();
	}

	};
	}


	// -- Unsafe access --

	private static Unsafe unsafe = Unsafe.getUnsafe();

	private static byte _get(long a) {
	return unsafe.getByte(a);
	}

	private static void _put(long a, byte b) {
	unsafe.putByte(a, b);
	}

	static void erase(ByteBuffer bb) {
	unsafe.setMemory(((DirectBuffer)bb).address(), bb.capacity(), (byte)0);
	}

	static Unsafe unsafe() {
	return unsafe;
	}

	private static int pageSize = -1;

	static int pageSize() {
	if (pageSize == -1)
	pageSize = unsafe().pageSize();
	return pageSize;
	}

	private static volatile Constructor<?> directByteBufferConstructor;

	private static void initDBBConstructor() {
	AccessController.doPrivileged(new PrivilegedAction<Void>() {
	public Void run() {
	try {
	Class<?> cl = Class.forName("java.nio.DirectByteBuffer");
	Constructor<?> ctor = cl.getDeclaredConstructor(
	new Class<?>[] { int.class,
	long.class,
	FileDescriptor.class,
	Runnable.class });
	ctor.setAccessible(true);
	directByteBufferConstructor = ctor;
	} catch (ClassNotFoundException \|
	NoSuchMethodException \|
	IllegalArgumentException \|
	ClassCastException x) {
	throw new InternalError(x);
	}
	return null;
	}});
	}

	static MappedByteBuffer newMappedByteBuffer(int size, long addr,
	FileDescriptor fd,
	Runnable unmapper)
	{
	MappedByteBuffer dbb;
	if (directByteBufferConstructor == null)
	initDBBConstructor();
	try {
	dbb = (MappedByteBuffer)directByteBufferConstructor.newInstance(
	new Object[] { size,
	addr,
	fd,
	unmapper });
	} catch (InstantiationException \|
	IllegalAccessException \|
	InvocationTargetException e) {
	throw new InternalError(e);
	}
	return dbb;
	}

	private static volatile Constructor<?> directByteBufferRConstructor;

	private static void initDBBRConstructor() {
	AccessController.doPrivileged(new PrivilegedAction<Void>() {
	public Void run() {
	try {
	Class<?> cl = Class.forName("java.nio.DirectByteBufferR");
	Constructor<?> ctor = cl.getDeclaredConstructor(
	new Class<?>[] { int.class,
	long.class,
	FileDescriptor.class,
	Runnable.class });
	ctor.setAccessible(true);
	directByteBufferRConstructor = ctor;
	} catch (ClassNotFoundException \|
	NoSuchMethodException \|
	IllegalArgumentException \|
	ClassCastException x) {
	throw new InternalError(x);
	}
	return null;
	}});
	}

	static MappedByteBuffer newMappedByteBufferR(int size, long addr,
	FileDescriptor fd,
	Runnable unmapper)
	{
	MappedByteBuffer dbb;
	if (directByteBufferRConstructor == null)
	initDBBRConstructor();
	try {
	dbb = (MappedByteBuffer)directByteBufferRConstructor.newInstance(
	new Object[] { size,
	addr,
	fd,
	unmapper });
	} catch (InstantiationException \|
	IllegalAccessException \|
	InvocationTargetException e) {
	throw new InternalError(e);
	}
	return dbb;
	}


	// -- Bug compatibility --

	private static volatile String bugLevel;

	static boolean atBugLevel(String bl) { // package-private
	if (bugLevel == null) {
	if (!sun.misc.VM.isBooted())
	return false;
	String value = AccessController.doPrivileged(
	new GetPropertyAction("sun.nio.ch.bugLevel"));
	bugLevel = (value != null) ? value : "";
	}
	return bugLevel.equals(bl);
	}

	}