Some sun.misc internal APIs are deprectaed in JDK 9 and will be encapsulated or removed in a future release.
public void freeAndClose() { cleaner.clean(); }
public static void unmap(MappedByteBuffer buffer) { sun.misc.Cleaner cleaner = ((DirectBuffer) buffer).cleaner(); cleaner.clean(); }
public static void clean(ByteBuffer bb) { if(bb == null) return; Cleaner cleaner = ((DirectBuffer) bb).cleaner(); if (cleaner != null) cleaner.clean(); }
public void freeAndClose() { cleaner.clean(); }
private static void clean(DirectBuffer buffer) { final Cleaner cleaner = buffer.cleaner(); if (cleaner != null) { cleaner.clean(); } } }
@Override void disposeCache(CacheHandler cacheHandler) { MapDbCacheDisposerAndCleaner disposerAndCleaner = (MapDbCacheDisposerAndCleaner) cacheHandler.id; disposerAndCleaner.cacheDisposer.disposeManually(); // This clean() call effectively just removes the Cleaner from the internal linked list of all cleaners. // The thunk.run() will be a no-op because cacheDisposer.disposed is already set to true. disposerAndCleaner.cleaner.clean(); }
@Override public void deallocate(MemoryBuffer buffer) { LlapAllocatorBuffer buf = (LlapAllocatorBuffer)buffer; ByteBuffer bb = buf.byteBuffer; buf.byteBuffer = null; if (!bb.isDirect()) return; Field field = cleanerField; if (field == null) return; try { ((Cleaner)field.get(bb)).clean(); } catch (Throwable t) { LlapIoImpl.LOG.warn("Error using DirectByteBuffer cleaner; stopping its use", t); cleanerField = null; } }
@Override protected void release() { Cleaner cleaner = ((DirectBuffer) _buffer).cleaner(); if (cleaner != null) { cleaner.clean(); } } }
@Override public void close() throws IOException { sun.misc.Cleaner cl = ((sun.nio.ch.DirectBuffer) buff).cleaner(); if(cl != null) { cl.clean(); } }
private static void unmap(MappedByteBuffer bb) { Cleaner cl = ((DirectBuffer) bb).cleaner(); if (cl != null) cl.clean(); }
@Override public void close() { if (buffer == null) return; Cleaner cleaner = ((DirectBuffer) buffer).cleaner(); cleaner.clean(); } }
private void clean(final ByteBuffer buffer) { if (buffer == null || !buffer.isDirect() || buffer.capacity() == 0) { return; } final Cleaner cleaner = ((DirectBuffer) buffer).cleaner(); cleaner.clean(); }
public static void close(ByteBuffer buffer) { if (buffer == null || !buffer.isDirect() || buffer.capacity() == 0) { return; } try { final Cleaner cleaner = ((DirectBuffer) buffer).cleaner(); cleaner.clean(); } catch (Exception ignore) { } } }
public static void clean(MappedByteBuffer buffer) { ((DirectBuffer) buffer).cleaner().clean(); }
@Override public void close() { if (!doClose(true)) { log.error("Cache for %s has already been closed", this); } // This Cleaner.clean() call effectively just removes the Cleaner from the internal linked list of all cleaners. // It will delegate to closeFromCleaner() which will be a no-op because cacheStateHolder is already set to // ENTRY_CLOSED. entryCleaner.clean(); }
private void unmapFile() { if (byteBuffer != null) { if (JAVA9_INVOKE_CLEANER == null || THE_UNSAFE == null) { if (byteBuffer instanceof DirectBuffer) { // for Java 8 and before ((DirectBuffer) byteBuffer).cleaner().clean(); } } else { // for Java 9 and later: // sun.nio.ch.DirectBuffer methods are not accessible, // so the new sun.misc.Unsafe.theUnsafe.invokeCleaner(ByteBuffer) is used. // See https://bugs.openjdk.java.net/browse/JDK-8171377 try { JAVA9_INVOKE_CLEANER.invoke(THE_UNSAFE, byteBuffer); } catch (final Exception e) { throw new IllegalStateException(e); } } byteBuffer = null; } }
private void releaseBuffer(ByteBuffer bb, boolean isFromDataReader) { if (isTracingEnabled) { LOG.trace("Releasing the buffer " + System.identityHashCode(bb)); } if (isFromDataReader && dataReader.isTrackingDiskRanges()) { dataReader.releaseBuffer(bb); return; } Field localCf = cleanerField; if (!bb.isDirect() || localCf == null) return; try { Cleaner cleaner = (Cleaner) localCf.get(bb); if (cleaner != null) { cleaner.clean(); } else { LOG.debug("Unable to clean a buffer using cleaner - no cleaner"); } } catch (Exception e) { // leave it for GC to clean up LOG.warn("Unable to clean direct buffers using Cleaner."); cleanerField = null; } }
/** * This should be impossible, because {@link ConcurrentLinkedQueue#offer(Object)} event don't have `return false;` in * it's body in OpenJDK 8. */ private void impossibleOffsetFailed(T object, ObjectId objectId, Cleaner cleaner, ObjectLeakNotifier notifier) { poolSize.decrementAndGet(); notifier.disable(); // Effectively does nothing, because notifier is disabled above. The purpose of this call is to deregister the // cleaner from the internal global linked list of all cleaners in the JVM, and let it be reclaimed itself. cleaner.clean(); log.error( new ISE("Queue offer failed"), "Could not offer object [%s] back into the queue, objectId [%s]", object, objectId ); }
private void tryReturnToPool(T object, ObjectId objectId, Cleaner cleaner, ObjectLeakNotifier notifier) { long currentPoolSize; do { currentPoolSize = poolSize.get(); if (currentPoolSize >= objectsCacheMaxCount) { notifier.disable(); // Effectively does nothing, because notifier is disabled above. The purpose of this call is to deregister the // cleaner from the internal global linked list of all cleaners in the JVM, and let it be reclaimed itself. cleaner.clean(); // Important to use the objectId after notifier.disable() (in the logging statement below), otherwise VM may // already decide that the objectId is unreachable and run Cleaner before notifier.disable(), that would be // reported as a false-positive "leak". Ideally reachabilityFence(objectId) should be inserted here. log.debug("cache num entries is exceeding in [%s], objectId [%s]", this, objectId); return; } } while (!poolSize.compareAndSet(currentPoolSize, currentPoolSize + 1)); if (!objects.offer(new ObjectResourceHolder(object, objectId, cleaner, notifier))) { impossibleOffsetFailed(object, objectId, cleaner, notifier); } }
public void shutdown() { removeMonitoring(); writeQ.clear(); readQ.clear(); inputQueue.clear(); try { // Cleanup the ByteBuffers only if they are sun.nio.ch.DirectBuffer // If we don't cleanup then we will leak 16K of memory if (getRbuf() instanceof DirectBuffer) { Cleaner cleaner = ((DirectBuffer) getRbuf()).cleaner(); if (cleaner != null) cleaner.clean(); cleaner = ((DirectBuffer) getWbuf()).cleaner(); if (cleaner != null) cleaner.clean(); } } catch (Throwable t) { getLogger().error("Exception cleaning ByteBuffer.", t); } }