src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template

*** 28,38 ****
  package java.nio;
  
  import java.io.FileDescriptor;
  import jdk.internal.misc.Unsafe;
  import jdk.internal.misc.VM;
! import jdk.internal.ref.Cleaner;
  import sun.nio.ch.DirectBuffer;
  
  
  class Direct$Type$Buffer$RW$$BO$
  #if[rw]
--- 28,39 ----
  package java.nio;
  
  import java.io.FileDescriptor;
  import jdk.internal.misc.Unsafe;
  import jdk.internal.misc.VM;
! import java.lang.ref.Cleaner;
! import jdk.internal.ref.CleanerFactory;
  import sun.nio.ch.DirectBuffer;
  
  
  class Direct$Type$Buffer$RW$$BO$
  #if[rw]
*** 67,76 ****
--- 68,107 ----
          return att;
      }
  
  #if[byte]
  
+     private static class Allocator
+         implements Supplier<Long>
+     {
+         private static final Unsafe unsafe = Unsafe.getUnsafe();
+ 
+         private final long size;
+         private final int capacity;
+ 
+         Allocator(long size, int capacity) {
+             this.size = size;
+             this.capacity = capacity;
+         }
+ 
+         @Override
+         public Long get() {
+             if (!Bits.tryReserveMemory(size, capacity)) {
+                 return null;
+             }
+             long address;
+             try {
+                 address = unsafe.allocateMemory(size);
+             } catch (OutOfMemoryError x) {
+                 Bits.unreserveMemory(size, capacity);
+                 return null;
+             }
+             unsafe.setMemory(address, size, (byte) 0);
+             return address;
+         }
+     }
+ 
      private static class Deallocator
          implements Runnable
      {
  
          private static Unsafe unsafe = Unsafe.getUnsafe();
*** 96,112 ****
              Bits.unreserveMemory(size, capacity);
          }
  
      }
  
!     private final Cleaner cleaner;
  
!     public Cleaner cleaner() { return cleaner; }
  
  #else[byte]
  
!     public Cleaner cleaner() { return null; }
  
  #end[byte]
  
  #end[rw]
  
--- 127,143 ----
              Bits.unreserveMemory(size, capacity);
          }
  
      }
  
!     private final Cleaner.Cleanable cleaner;
  
!     public Cleaner.Cleanable cleaner() { return cleaner; }
  
  #else[byte]
  
!     public Cleaner.Cleanable cleaner() { return null; }
  
  #end[byte]
  
  #end[rw]
  
*** 118,144 ****
  #if[rw]
          super(-1, 0, cap, cap);
          boolean pa = VM.isDirectMemoryPageAligned();
          int ps = Bits.pageSize();
          long size = Math.max(1L, (long)cap + (pa ? ps : 0));
-         Bits.reserveMemory(size, cap);
  
!         long base = 0;
!         try {
!             base = unsafe.allocateMemory(size);
!         } catch (OutOfMemoryError x) {
!             Bits.unreserveMemory(size, cap);
!             throw x;
          }
!         unsafe.setMemory(base, size, (byte) 0);
          if (pa && (base % ps != 0)) {
              // Round up to page boundary
              address = base + ps - (base & (ps - 1));
          } else {
              address = base;
          }
!         cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
          att = null;
  #else[rw]
          super(cap);
  #end[rw]
      }
--- 149,171 ----
  #if[rw]
          super(-1, 0, cap, cap);
          boolean pa = VM.isDirectMemoryPageAligned();
          int ps = Bits.pageSize();
          long size = Math.max(1L, (long)cap + (pa ? ps : 0));
  
!         Long base = CleanerFactory.dbbCleaner().retryWhileHelpingClean(new Allocator(size, cap));
!         if (base == null) {
!             throw new OutOfMemoryError("Direct buffer memory");
          }
! 
          if (pa && (base % ps != 0)) {
              // Round up to page boundary
              address = base + ps - (base & (ps - 1));
          } else {
              address = base;
          }
!         cleaner = CleanerFactory.dbbCleaner().register(this, new Deallocator(base, size, cap));
          att = null;
  #else[rw]
          super(cap);
  #end[rw]
      }
*** 174,184 ****
                                       Runnable unmapper)
      {
  #if[rw]
          super(-1, 0, cap, cap, fd);
          address = addr;
!         cleaner = Cleaner.create(this, unmapper);
          att = null;
  #else[rw]
          super(cap, addr, fd, unmapper);
  #end[rw]
      }
--- 201,213 ----
                                       Runnable unmapper)
      {
  #if[rw]
          super(-1, 0, cap, cap, fd);
          address = addr;
!         cleaner = (unmapper == null)
!                   ? null
!                   : CleanerFactory.dbbCleaner().register(this, unmapper);
          att = null;
  #else[rw]
          super(cap, addr, fd, unmapper);
  #end[rw]
      }