190         long totalCap;
 191         while (cap <= MAX_MEMORY - (totalCap = TOTAL_CAPACITY.get())) {
 192             if (TOTAL_CAPACITY.compareAndSet(totalCap, totalCap + cap)) {
 193                 RESERVED_MEMORY.addAndGet(size);
 194                 COUNT.incrementAndGet();
 195                 return true;
 196             }
 197         }
 198 
 199         return false;
 200     }
 201 
 202 
 203     static void unreserveMemory(long size, int cap) {
 204         long cnt = COUNT.decrementAndGet();
 205         long reservedMem = RESERVED_MEMORY.addAndGet(-size);
 206         long totalCap = TOTAL_CAPACITY.addAndGet(-cap);
 207         assert cnt >= 0 && reservedMem >= 0 && totalCap >= 0;
 208     }
 209 
 210     // -- Monitoring of direct buffer usage --
 211 
 212     static {
 213         // setup access to this package in SharedSecrets
 214         SharedSecrets.setJavaNioAccess(
 215             new JavaNioAccess() {
 216                 @Override
 217                 public JavaNioAccess.BufferPool getDirectBufferPool() {
 218                     return new JavaNioAccess.BufferPool() {
 219                         @Override
 220                         public String getName() {
 221                             return "direct";
 222                         }
 223                         @Override
 224                         public long getCount() {
 225                             return Bits.COUNT.get();
 226                         }
 227                         @Override
 228                         public long getTotalCapacity() {
 229                             return Bits.TOTAL_CAPACITY.get();
 230                         }
 231                         @Override
 232                         public long getMemoryUsed() {
 233                             return Bits.RESERVED_MEMORY.get();
 234                         }
 235                     };
 236                 }
 237                 @Override
 238                 public ByteBuffer newDirectByteBuffer(long addr, int cap, Object ob) {
 239                     return new DirectByteBuffer(addr, cap, ob);
 240                 }
 241                 @Override
 242                 public void truncate(Buffer buf) {
 243                     buf.truncate();
 244                 }
 245         });
 246     }
 247 
 248     // These numbers represent the point at which we have empirically
 249     // determined that the average cost of a JNI call exceeds the expense
 250     // of an element by element copy.  These numbers may change over time.
 251     static final int JNI_COPY_TO_ARRAY_THRESHOLD   = 6;
 252     static final int JNI_COPY_FROM_ARRAY_THRESHOLD = 6;
 253 }

 190         long totalCap;
 191         while (cap <= MAX_MEMORY - (totalCap = TOTAL_CAPACITY.get())) {
 192             if (TOTAL_CAPACITY.compareAndSet(totalCap, totalCap + cap)) {
 193                 RESERVED_MEMORY.addAndGet(size);
 194                 COUNT.incrementAndGet();
 195                 return true;
 196             }
 197         }
 198 
 199         return false;
 200     }
 201 
 202 
 203     static void unreserveMemory(long size, int cap) {
 204         long cnt = COUNT.decrementAndGet();
 205         long reservedMem = RESERVED_MEMORY.addAndGet(-size);
 206         long totalCap = TOTAL_CAPACITY.addAndGet(-cap);
 207         assert cnt >= 0 && reservedMem >= 0 && totalCap >= 0;
 208     }
 209 
 210     static final JavaNioAccess.BufferPool BUFFER_POOL = new JavaNioAccess.BufferPool() {








 211         @Override
 212         public String getName() {
 213             return "direct";
 214         }
 215         @Override
 216         public long getCount() {
 217             return Bits.COUNT.get();
 218         }
 219         @Override
 220         public long getTotalCapacity() {
 221             return Bits.TOTAL_CAPACITY.get();
 222         }
 223         @Override
 224         public long getMemoryUsed() {
 225             return Bits.RESERVED_MEMORY.get();
 226         }
 227     };











 228 
 229     // These numbers represent the point at which we have empirically
 230     // determined that the average cost of a JNI call exceeds the expense
 231     // of an element by element copy.  These numbers may change over time.
 232     static final int JNI_COPY_TO_ARRAY_THRESHOLD   = 6;
 233     static final int JNI_COPY_FROM_ARRAY_THRESHOLD = 6;
 234 }