https://openjdk.java.net/ 
/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.jfr.internal;

import java.io.IOException;
import java.util.List;

import jdk.internal.HotSpotIntrinsicCandidate;
import jdk.jfr.Event;


Interface against the JVM.

/**
 * Interface against the JVM.
 *
 */
public final class JVM {
    private static final JVM jvm = new JVM();

    // JVM signals file changes by doing Object#notifu on this object
    static final Object FILE_DELTA_CHANGE = new Object();

    static final long RESERVED_CLASS_ID_LIMIT = 400;

    private volatile boolean recording;
    private volatile boolean nativeOK;

    private static native void registerNatives();

    static {
        registerNatives();
        for (LogTag tag : LogTag.values()) {
            subscribeLogLevel(tag, tag.id);
        }
        Options.ensureInitialized();
    }

    
Get the one and only JVM.

Returns:the JVM
/**
     * Get the one and only JVM.
     *
     * @return the JVM
     */
    public static JVM getJVM() {
        return jvm;
    }

    private JVM() {
    }

    
Begin recording events Requires that JFR has been started with createNativeJFR() 
/**
     * Begin recording events
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     */
    public native void beginRecording();

    
Return ticks

Returns:the time, in ticks
/**
     * Return ticks
     *
     * @return the time, in ticks
     *
     */
    @HotSpotIntrinsicCandidate
    public static native long counterTime();


    
Emits native periodic event.

Params:
  • eventTypeId – type id
  • timestamp – commit time for event
  • when – when it is being done When
Returns:true if the event was committed
/**
     * Emits native periodic event.
     *
     * @param eventTypeId type id
     *
     * @param timestamp commit time for event
     * @param when when it is being done {@link Periodic.When}
     *
     * @return true if the event was committed
     */
    public native boolean emitEvent(long eventTypeId, long timestamp, long when);

    
End recording events, which includes flushing data in thread buffers Requires that JFR has been started with createNativeJFR() 
/**
     * End recording events, which includes flushing data in thread buffers
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     *
     */
    public native void endRecording();

    
Return a list of all classes deriving from Event 
Returns:list of event classes.
/**
     * Return a list of all classes deriving from {@link jdk.internal.event.Event}
     *
     * @return list of event classes.
     */
    public native List<Class<? extends jdk.internal.event.Event>> getAllEventClasses();

    
Return a count of the number of unloaded classes deriving from Event 
Returns:number of unloaded event classes.
/**
     * Return a count of the number of unloaded classes deriving from {@link Event}
     *
     * @return number of unloaded event classes.
     */
    public native long getUnloadedEventClassCount();

    
Return a unique identifier for a class. The class is marked as being
"in use" in JFR.

Params:
  • clazz – clazz
Returns:a unique class identifier
/**
     * Return a unique identifier for a class. The class is marked as being
     * "in use" in JFR.
     *
     * @param clazz clazz
     *
     * @return a unique class identifier
     */
   @HotSpotIntrinsicCandidate
    public static native long getClassId(Class<?> clazz);

    // temporary workaround until we solve intrinsics supporting epoch shift tagging
    public static native long getClassIdNonIntrinsic(Class<?> clazz);

    
Return process identifier.

Returns:process identifier
/**
     * Return process identifier.
     *
     * @return process identifier
     */
    public native String getPid();

    
Return unique identifier for stack trace. Requires that JFR has been started with createNativeJFR() 
Params:
  • skipCount – number of frames to skip
Returns:a unique stack trace identifier
/**
     * Return unique identifier for stack trace.
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     *
     * @param skipCount number of frames to skip
     * @return a unique stack trace identifier
     */
    public native long getStackTraceId(int skipCount);

    
Return identifier for thread

Params:
  • t – thread
Returns:a unique thread identifier
/**
     * Return identifier for thread
     *
     * @param t thread
     * @return a unique thread identifier
     */
    public native long getThreadId(Thread t);

    
Frequency, ticks per second

Returns:frequency
/**
     * Frequency, ticks per second
     *
     * @return frequency
     */
    public native long getTicksFrequency();

    
Write message to log. Should swallow null or empty message, and be able
to handle any Java character and not crash with very large message

Params:
  • tagSetId – the tagset id
  • level – on level
  • message – log message
/**
     * Write message to log. Should swallow null or empty message, and be able
     * to handle any Java character and not crash with very large message
     *
     * @param tagSetId the tagset id
     * @param level on level
     * @param message log message
     *
     */
    public static native void log(int tagSetId, int level, String message);

    
Subscribe to LogLevel updates for LogTag

Params:
  • lt – the log tag to subscribe
  • tagSetId – the tagset id
/**
     * Subscribe to LogLevel updates for LogTag
     *
     * @param lt the log tag to subscribe
     * @param tagSetId the tagset id
     */
    public static native void subscribeLogLevel(LogTag lt, int tagSetId);

    
Call to invoke event tagging and retransformation of the passed classes

Params:
  • classes – 
Throws:
/**
     * Call to invoke event tagging and retransformation of the passed classes
     *
     * @param classes
     *
     * @throws IllegalStateException if wrong JVMTI phase.
     */
    public native synchronized void retransformClasses(Class<?>[] classes);

    
Enable event

Params:
  • eventTypeId – event type id
  • enabled – enable event
/**
     * Enable event
     *
     * @param eventTypeId event type id
     *
     * @param enabled enable event
     */
    public native void setEnabled(long eventTypeId, boolean enabled);

    
Interval at which the JVM should notify on FILE_DELTA_CHANGE 
Params:
  • delta – number of bytes, reset after file rotation
/**
     * Interval at which the JVM should notify on {@link #FILE_DELTA_CHANGE}
     *
     * @param delta number of bytes, reset after file rotation
     */
    public native void setFileNotification(long delta);

    
Set the number of global buffers to use

Params:
  • count – 
Throws:
/**
     * Set the number of global buffers to use
     *
     * @param count
     *
     * @throws IllegalArgumentException if count is not within a valid range
     * @throws IllegalStateException if value can't be changed
     */
    public native void setGlobalBufferCount(long count) throws IllegalArgumentException, IllegalStateException;

    
Set size of a global buffer

Params:
  • size – 
Throws:
/**
     * Set size of a global buffer
     *
     * @param size
     *
     * @throws IllegalArgumentException if buffer size is not within a valid
     *         range
     */
    public native void setGlobalBufferSize(long size) throws IllegalArgumentException;

    
Set overall memory size

Params:
  • size – 
Throws:
/**
     * Set overall memory size
     *
     * @param size
     *
     * @throws IllegalArgumentException if memory size is not within a valid
     *         range
     */
    public native void setMemorySize(long size) throws IllegalArgumentException;

    
/**
Set interval for method samples, in milliseconds.
Setting interval to 0 turns off the method sampler.

Params:
  • intervalMillis – the sampling interval
/**

    /**
     * Set interval for method samples, in milliseconds.
     *
     * Setting interval to 0 turns off the method sampler.
     *
     * @param intervalMillis the sampling interval
     */
    public native void setMethodSamplingInterval(long type, long intervalMillis);

      
Sets the file where data should be written. Requires that JFR has been started with createNativeJFR() 
Recording Previous Current Action ============================================== true null null Ignore, keep recording in-memory true null file1 Start disk recording true file null Copy out metadata to disk and continue in-memory recording true file1 file2 Copy out metadata and start with new File (file2) false * null Ignore, but start recording to memory with beginRecording() false * file Ignore, but start recording to disk with beginRecording() 
 recording can be set to true/false with beginRecording() endRecording() 
Params:
  • file – the file where data should be written, or null if it should
       not be copied out (in memory).
Throws:
/**
     * Sets the file where data should be written.
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     *
     * <pre>
     * Recording  Previous  Current  Action
     * ==============================================
     *    true     null      null     Ignore, keep recording in-memory
     *    true     null      file1    Start disk recording
     *    true     file      null     Copy out metadata to disk and continue in-memory recording
     *    true     file1     file2    Copy out metadata and start with new File (file2)
     *    false     *        null     Ignore, but start recording to memory with {@link #beginRecording()}
     *    false     *        file     Ignore, but start recording to disk with {@link #beginRecording()}
     *
     * </pre>
     *
     * recording can be set to true/false with {@link #beginRecording()}
     * {@link #endRecording()}
     *
     * @param file the file where data should be written, or null if it should
     *        not be copied out (in memory).
     *
     * @throws IOException
     */
    public native void setOutput(String file);

    
Controls if a class deriving from jdk.jfr.Event should
always be instrumented on class load.

@paramforce, true to force initialization, false otherwise
/**
     * Controls if a class deriving from jdk.jfr.Event should
     * always be instrumented on class load.
     *
     * @param force, true to force initialization, false otherwise
     */
    public native void setForceInstrumentation(boolean force);

    
Turn on/off thread sampling.

Params:
  • sampleThreads – true if threads should be sampled, false otherwise.
Throws:
/**
     * Turn on/off thread sampling.
     *
     * @param sampleThreads true if threads should be sampled, false otherwise.
     *
     * @throws IllegalStateException if state can't be changed.
     */
    public native void setSampleThreads(boolean sampleThreads) throws IllegalStateException;

    
Turn on/off compressed integers.

Params:
  • compressed – true if compressed integers should be used, false
       otherwise.
Throws:
/**
     * Turn on/off compressed integers.
     *
     * @param compressed true if compressed integers should be used, false
     *        otherwise.
     *
     * @throws IllegalStateException if state can't be changed.
     */
    public native void setCompressedIntegers(boolean compressed) throws IllegalStateException;

    
Set stack depth.

Params:
  • depth – 
Throws:
/**
     * Set stack depth.
     *
     * @param depth
     *
     * @throws IllegalArgumentException if not within a valid range
     * @throws IllegalStateException if depth can't be changed
     */
    public native void setStackDepth(int depth) throws IllegalArgumentException, IllegalStateException;

    
Turn on stack trace for an event

Params:
  • eventTypeId – the event id
  • enabled – if stack traces should be enabled
/**
     * Turn on stack trace for an event
     *
     * @param eventTypeId the event id
     *
     * @param enabled if stack traces should be enabled
     */
    public native void setStackTraceEnabled(long eventTypeId, boolean enabled);

    
Set thread buffer size.

Params:
  • size – 
Throws:
/**
     * Set thread buffer size.
     *
     * @param size
     *
     * @throws IllegalArgumentException if size is not within a valid range
     * @throws IllegalStateException if size can't be changed
     */
    public native void setThreadBufferSize(long size) throws IllegalArgumentException, IllegalStateException;

    
Set threshold for event,
Long.MAXIMUM_VALUE = no limit

Params:
  • eventTypeId – the id of the event type
  • ticks – threshold in ticks,
Returns:true, if it could be set
/**
     * Set threshold for event,
     *
     * Long.MAXIMUM_VALUE = no limit
     *
     * @param eventTypeId the id of the event type
     * @param ticks threshold in ticks,
     * @return true, if it could be set
     */
    public native boolean setThreshold(long eventTypeId, long ticks);

    
Store the metadata descriptor that is to be written at the end of a chunk, data should be written after GMT offset and size of metadata event should be adjusted Requires that JFR has been started with createNativeJFR() 
Params:
  • bytes – binary representation of metadata descriptor
  • binary – representation of descriptor
/**
     * Store the metadata descriptor that is to be written at the end of a
     * chunk, data should be written after GMT offset and size of metadata event
     * should be adjusted
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     *
     * @param bytes binary representation of metadata descriptor
     *
     * @param binary representation of descriptor
     */
    public native void storeMetadataDescriptor(byte[] bytes);

    public void endRecording_() {
        endRecording();
        recording = false;
    }

    public void beginRecording_() {
        beginRecording();
        recording = true;
    }

    public boolean isRecording() {
        return recording;
    }

    
If the JVM supports JVM TI and retransformation has not been disabled this
method will return true. This flag can not change during the lifetime of
the JVM.

Returns:if transform is allowed
/**
     * If the JVM supports JVM TI and retransformation has not been disabled this
     * method will return true. This flag can not change during the lifetime of
     * the JVM.
     *
     * @return if transform is allowed
     */
    public native boolean getAllowedToDoEventRetransforms();

    
Set up native resources, data structures, threads etc. for JFR

Params:
  • simulateFailure – simulate a initialization failure and rollback in
       native, used for testing purposes
Throws:
/**
     * Set up native resources, data structures, threads etc. for JFR
     *
     * @param simulateFailure simulate a initialization failure and rollback in
     *        native, used for testing purposes
     *
     * @throws IllegalStateException if native part of JFR could not be created.
     *
     */
    private native boolean createJFR(boolean simulateFailure) throws IllegalStateException;

    
Destroys native part of JFR. If already destroy, call is ignored. Requires that JFR has been started with createNativeJFR() 
Returns:if an instance was actually destroyed.
/**
     * Destroys native part of JFR. If already destroy, call is ignored.
     *
     * Requires that JFR has been started with {@link #createNativeJFR()}
     *
     * @return if an instance was actually destroyed.
     *
     */
    private native boolean destroyJFR();

    public boolean createFailedNativeJFR() throws IllegalStateException {
        return createJFR(true);
    }

    public void createNativeJFR() {
        nativeOK = createJFR(false);
    }

    public boolean destroyNativeJFR() {
        boolean result = destroyJFR();
        nativeOK = !result;
        return result;
    }

    public boolean hasNativeJFR() {
        return nativeOK;
    }

    
Cheap test to check if JFR functionality is available.

Returns:
/**
     * Cheap test to check if JFR functionality is available.
     *
     * @return
     */
    public native boolean isAvailable();

    
To convert ticks to wall clock time.

/**
     * To convert ticks to wall clock time.
     */
    public native double getTimeConversionFactor();

    
Return a unique identifier for a class. Compared to getClassId() , this method does not tag the class as being "in-use". 
Params:
  • clazz – class
Returns:a unique class identifier
/**
     * Return a unique identifier for a class. Compared to {@link #getClassId()}
     * , this method does not tag the class as being "in-use".
     *
     * @param clazz class
     *
     * @return a unique class identifier
     */
    public native long getTypeId(Class<?> clazz);

    
Fast path fetching the EventWriter using VM intrinsics

Returns:thread local EventWriter
/**
     * Fast path fetching the EventWriter using VM intrinsics
     *
     * @return thread local EventWriter
     */
    @HotSpotIntrinsicCandidate
    public static native Object getEventWriter();

    
Create a new EventWriter

Returns:thread local EventWriter
/**
     * Create a new EventWriter
     *
     * @return thread local EventWriter
     */
    public static native EventWriter newEventWriter();

    
Flushes the EventWriter for this thread.

/**
     * Flushes the EventWriter for this thread.
     */
    public static native boolean flush(EventWriter writer, int uncommittedSize, int requestedSize);

    
Sets the location of the disk repository, to be used at an emergency
dump.

Params:
  • dirText – 
/**
     * Sets the location of the disk repository, to be used at an emergency
     * dump.
     *
     * @param dirText
     */
    public native void setRepositoryLocation(String dirText);

    
Access to VM termination support.

Params:
  • errorMsg – descriptive message to be include in VM termination sequence
/**
    * Access to VM termination support.
    *
    *@param errorMsg descriptive message to be include in VM termination sequence
    */
    public native void abort(String errorMsg);

    
Adds a string to the string constant pool.
If the same string is added twice, two entries will be created.

Params:
  • id – identifier associated with the string, not negative
  • s – string constant to be added, not null
Returns:the current epoch of this insertion attempt
/**
     * Adds a string to the string constant pool.
     *
     * If the same string is added twice, two entries will be created.
     *
     * @param id identifier associated with the string, not negative
     *
     * @param s string constant to be added, not null
     *
     * @return the current epoch of this insertion attempt
     */
    public static native boolean addStringConstant(boolean epoch, long id, String s);
    
Gets the address of the jboolean epoch.
The epoch alternates every checkpoint.

Returns:The address of the jboolean.
/**
     * Gets the address of the jboolean epoch.
     *
     * The epoch alternates every checkpoint.
     *
     * @return The address of the jboolean.
     */
    public native long getEpochAddress();

    public native void uncaughtException(Thread thread, Throwable t);
    
Sets cutoff for event.
Determines how long the event should be allowed to run.
Long.MAXIMUM_VALUE = no limit

Params:
  • eventTypeId – the id of the event type
  • cutoffTicks – cutoff in ticks,
Returns:true, if it could be set
/**
     * Sets cutoff for event.
     *
     * Determines how long the event should be allowed to run.
     *
     * Long.MAXIMUM_VALUE = no limit
     *
     * @param eventTypeId the id of the event type
     * @param cutoffTicks cutoff in ticks,
     * @return true, if it could be set
     */
    public native boolean setCutoff(long eventTypeId, long cutoffTicks);

    
Emit old object sample events.

Params:
  • cutoff – the cutoff in ticks
  • emitAll – emit all samples in old object queue
/**
     * Emit old object sample events.
     *
     * @param cutoff the cutoff in ticks
     * @param emitAll emit all samples in old object queue
     */
    public native void emitOldObjectSamples(long cutoff, boolean emitAll);

    
Test if a chunk rotation is warranted.

Returns:if it is time to perform a chunk rotation
/**
     * Test if a chunk rotation is warranted.
     *
     * @return if it is time to perform a chunk rotation
     */
    public native boolean shouldRotateDisk();
}