< prev index next >

src/java.base/share/classes/java/nio/Bits.java

Print this page




  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.nio;
  27 
  28 import java.util.concurrent.atomic.AtomicLong;
  29 
  30 import jdk.internal.misc.JavaNioAccess;
  31 import jdk.internal.misc.JavaLangRefAccess;
  32 import jdk.internal.misc.SharedSecrets;
  33 import jdk.internal.misc.Unsafe;
  34 import jdk.internal.misc.VM;

  35 
  36 /**
  37  * Access to bits, native and otherwise.
  38  */
  39 
  40 class Bits {                            // package-private
  41 
  42     private Bits() { }
  43 
  44 
  45     // -- Swapping --
  46 
  47     static short swap(short x) {
  48         return Short.reverseBytes(x);
  49     }
  50 
  51     static char swap(char x) {
  52         return Character.reverseBytes(x);
  53     }
  54 


 607     // increasing delay before throwing OutOfMemoryError:
 608     // 1, 2, 4, 8, 16, 32, 64, 128, 256 (total 511 ms ~ 0.5 s)
 609     // which means that OOME will be thrown after 0.5 s of trying
 610     private static final int MAX_SLEEPS = 9;
 611 
 612     // These methods should be called whenever direct memory is allocated or
 613     // freed.  They allow the user to control the amount of direct memory
 614     // which a process may access.  All sizes are specified in bytes.
 615     static void reserveMemory(long size, int cap) {
 616 
 617         if (!memoryLimitSet && VM.isBooted()) {
 618             maxMemory = VM.maxDirectMemory();
 619             memoryLimitSet = true;
 620         }
 621 
 622         // optimist!
 623         if (tryReserveMemory(size, cap)) {
 624             return;
 625         }
 626 
 627         final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
 628 
 629         // retry while helping enqueue pending Reference objects
 630         // which includes executing pending Cleaner(s) which includes
 631         // Cleaner(s) that free direct buffer memory
 632         while (jlra.tryHandlePendingReference()) {
 633             if (tryReserveMemory(size, cap)) {
 634                 return;
 635             }
 636         }
 637 
 638         // trigger VM's Reference processing
 639         System.gc();
 640 
 641         // a retry loop with exponential back-off delays
 642         // (this gives VM some time to do it's job)
 643         boolean interrupted = false;
 644         try {
 645             long sleepTime = 1;
 646             int sleeps = 0;
 647             while (true) {
 648                 if (tryReserveMemory(size, cap)) {
 649                     return;
 650                 }
 651                 if (sleeps >= MAX_SLEEPS) {
 652                     break;
 653                 }
 654                 if (!jlra.tryHandlePendingReference()) {
 655                     try {
 656                         Thread.sleep(sleepTime);
 657                         sleepTime <<= 1;
 658                         sleeps++;
 659                     } catch (InterruptedException e) {
 660                         interrupted = true;
 661                     }
 662                 }
 663             }
 664 
 665             // no luck
 666             throw new OutOfMemoryError("Direct buffer memory");
 667 
 668         } finally {
 669             if (interrupted) {
 670                 // don't swallow interrupts
 671                 Thread.currentThread().interrupt();
 672             }
 673         }
 674     }




  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.nio;
  27 
  28 import java.util.concurrent.atomic.AtomicLong;
  29 
  30 import jdk.internal.misc.JavaNioAccess;

  31 import jdk.internal.misc.SharedSecrets;
  32 import jdk.internal.misc.Unsafe;
  33 import jdk.internal.misc.VM;
  34 import jdk.internal.ref.CleanerFactory;
  35 
  36 /**
  37  * Access to bits, native and otherwise.
  38  */
  39 
  40 class Bits {                            // package-private
  41 
  42     private Bits() { }
  43 
  44 
  45     // -- Swapping --
  46 
  47     static short swap(short x) {
  48         return Short.reverseBytes(x);
  49     }
  50 
  51     static char swap(char x) {
  52         return Character.reverseBytes(x);
  53     }
  54 


 607     // increasing delay before throwing OutOfMemoryError:
 608     // 1, 2, 4, 8, 16, 32, 64, 128, 256 (total 511 ms ~ 0.5 s)
 609     // which means that OOME will be thrown after 0.5 s of trying
 610     private static final int MAX_SLEEPS = 9;
 611 
 612     // These methods should be called whenever direct memory is allocated or
 613     // freed.  They allow the user to control the amount of direct memory
 614     // which a process may access.  All sizes are specified in bytes.
 615     static void reserveMemory(long size, int cap) {
 616 
 617         if (!memoryLimitSet && VM.isBooted()) {
 618             maxMemory = VM.maxDirectMemory();
 619             memoryLimitSet = true;
 620         }
 621 
 622         // optimist!
 623         if (tryReserveMemory(size, cap)) {
 624             return;
 625         }
 626 
 627         // retry while helping the Cleaner thread process Cleanable(s) which
 628         // includes the ones that free direct buffer memory
 629         while (CleanerFactory.cleaner().helpClean()) {



 630             if (tryReserveMemory(size, cap)) {
 631                 return;
 632             }
 633         }
 634 
 635         // trigger VM's Reference processing
 636         System.gc();
 637 
 638         // a retry loop with exponential back-off delays
 639         // (this gives VM some time to do it's job)
 640         boolean interrupted = false;
 641         try {
 642             long sleepTime = 1;
 643             int sleeps = 0;
 644             while (true) {
 645                 if (tryReserveMemory(size, cap)) {
 646                     return;
 647                 }
 648                 if (sleeps >= MAX_SLEEPS) {
 649                     break;
 650                 }
 651                 if (!CleanerFactory.cleaner().helpClean()) {
 652                     try {
 653                         Thread.sleep(sleepTime);
 654                         sleepTime <<= 1;
 655                         sleeps++;
 656                     } catch (InterruptedException e) {
 657                         interrupted = true;
 658                     }
 659                 }
 660             }
 661 
 662             // no luck
 663             throw new OutOfMemoryError("Direct buffer memory");
 664 
 665         } finally {
 666             if (interrupted) {
 667                 // don't swallow interrupts
 668                 Thread.currentThread().interrupt();
 669             }
 670         }
 671     }


< prev index next >