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
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 }
|
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 import jdk.internal.ref.CleanerFactory;
36 import jdk.internal.ref.CleanerImpl;
37
38 /**
39 * Access to bits, native and otherwise.
40 */
41
42 class Bits { // package-private
43
44 private Bits() { }
45
46
47 // -- Swapping --
48
49 static short swap(short x) {
50 return Short.reverseBytes(x);
51 }
52
53 static char swap(char x) {
54 return Character.reverseBytes(x);
55 }
56
611 // which means that OOME will be thrown after 0.5 s of trying
612 private static final int MAX_SLEEPS = 9;
613
614 // These methods should be called whenever direct memory is allocated or
615 // freed. They allow the user to control the amount of direct memory
616 // which a process may access. All sizes are specified in bytes.
617 static void reserveMemory(long size, int cap) {
618
619 if (!memoryLimitSet && VM.isBooted()) {
620 maxMemory = VM.maxDirectMemory();
621 memoryLimitSet = true;
622 }
623
624 // optimist!
625 if (tryReserveMemory(size, cap)) {
626 return;
627 }
628
629 final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
630
631 // retry while:
632 // - helping enqueue pending Reference objects which includes Cleanable(s)
633 // - helping processing the queue of Cleanable(s) which includes the ones
634 // that free direct buffer memory
635 while (jlra.tryHandlePendingReference() | // use non-short-circuit or
636 CleanerImpl.getCleanerImpl(CleanerFactory.cleaner()).drainQueue()) {
637 if (tryReserveMemory(size, cap)) {
638 return;
639 }
640 }
641
642 // trigger VM's Reference processing
643 System.gc();
644
645 // a retry loop with exponential back-off delays
646 // (this gives VM some time to do it's job)
647 boolean interrupted = false;
648 try {
649 long sleepTime = 1;
650 int sleeps = 0;
651 while (true) {
652 if (tryReserveMemory(size, cap)) {
653 return;
654 }
655 if (sleeps >= MAX_SLEEPS) {
656 break;
657 }
658 if (!jlra.tryHandlePendingReference() & // use non-short-circuit and
659 !CleanerImpl.getCleanerImpl(CleanerFactory.cleaner()).drainQueue()) {
660 try {
661 Thread.sleep(sleepTime);
662 sleepTime <<= 1;
663 sleeps++;
664 } catch (InterruptedException e) {
665 interrupted = true;
666 }
667 }
668 }
669
670 // no luck
671 throw new OutOfMemoryError("Direct buffer memory");
672
673 } finally {
674 if (interrupted) {
675 // don't swallow interrupts
676 Thread.currentThread().interrupt();
677 }
678 }
679 }
|