public final Class JVM

Access to VM termination support.

Parameters

errorMsg:String

descriptive message to be include in VM termination sequence

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

Parameters

id:long

identifier associated with the string, not negative

s:String

string constant to be added, not null

Returns:boolean

true, if the string was successfully added.

Begin recording events Requires that JFR has been started with JVMSupport#createJFR()

Commits an event to the underlying buffer by setting the nextPosition.

Returns:long

the next startPosition

Annotations

@IntrinsicCandidate

Return ticks

Returns:long

the time, in ticks

Annotations

@IntrinsicCandidate

Returns IDs for method-traced classes that have been unloaded.

Returns:long[]

the unloaded IDs, or null if no unloading has occurred.

Emit a jdk.DataLoss event for the specified amount of bytes.

Parameters

bytes:long

number of bytes that were lost

Emits native periodic event.

Parameters

eventTypeId:long

type id

timestamp:long

commit time for event

periodicType:long

when it is being done PeriodicType.When

Returns:boolean

true if the event was committed

Emit old object sample events.

Parameters

cutoff:long

the cutoff in ticks

emitAll:boolean

emit all samples in old object queue

skipBFS:boolean

don't use BFS when searching for path to GC root

End recording events, which includes flushing data in thread buffers Requires that JFR has been started with JVMSupport#createJFR()

Exclude a thread from the jfr system

Flushes the EventWriter for this thread.

Flushes all thread buffers to disk and the constant pool data needed to read them.

When the method returns, the chunk header should be updated with valid pointers to the metadata event, last check point event, correct file size and the generation id.

Return a list of all classes deriving from jdk.internal.event.Event

Returns:List<Class<? extends Event>>

list of event classes.

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:boolean

if transform is allowed

Get the start time in nanos from the header of the current chunk

Returns:long

start time of the recording in nanos, -1 in case of in-memory

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

Parameters

clazz:Class<?>

clazz

Returns:long

a unique class identifier

Annotations

@IntrinsicCandidate

Retrieves the EventConfiguration for an event class.

Parameters

eventClass:Class<? extends Event>

the class, not null

Returns:Object

the configuration, may be null

Gets the path to emergency dump.

Returns:String

The path to emergency dump.

Fast path fetching the EventWriter using VM intrinsics

Returns:EventWriter

thread local EventWriter

Annotations

@IntrinsicCandidate

Return process identifier.

Returns:String

process identifier

Return unique identifier for stack trace. Requires that JFR has been started with JVMSupport#createJFR()

Parameters

skipCount:int

number of frames to skip, or 0 if no frames should be skipped

Returns:long

a unique stack trace identifier

Return identifier for thread

Parameters

t:Thread

thread

Returns:long

a unique thread identifier

Frequency, ticks per second

Returns:long

frequency

To convert ticks to wall clock time.

Return a unique identifier for a class. Compared to getClassId(Class), this method does not tag the class as being "in-use".

Parameters

clazz:Class<?>

class

Returns:long

a unique class identifier

Returns the id for the Java types defined in metadata.xml.

Parameters

name:String

the name of the type

Returns:long

the id, or a negative value if it does not exists.

Return a count of the number of unloaded classes deriving from Event

Returns:long

number of unloaded event classes.

Returns the amount of memory used in the host system whether or not this JVM runs in a container.

Returns the total amount of memory of the host system whether or not this JVM runs in a container.

Returns the total amount of swap memory of the host system whether or not this JVM runs in a container.

Include a thread back into the jfr system

Cheap test to check if JFR functionality is available.

Returns true, if the JVM is running in a container, false otherwise.

If -XX:-UseContainerSupport has been specified, this method returns false, which is questionable, but Container.metrics() returns null, so events can't be emitted anyway.

Test if a thread is currently excluded from the jfr system.

Returns:boolean

is thread currently excluded

Test if a class is excluded from the jfr system.

Parameters

eventClass:Class<? extends Event>

the class, not null

Returns:boolean

is class excluded

Test if a class is instrumented.

Parameters

eventClass:Class<? extends Event>

the class, not null

Returns:boolean

is class instrumented

Returns whether the current build is a product build.

Returns:boolean

true if this is a product build, false otherwise.

Return true if the JVM is recording

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

Parameters

tagSetId:int

the tagset id

level:int

on level

message:String

log message

Log an event to jfr+event or jfr+event+system.

Caller should ensure that message is not null or too large to handle.

Parameters

level:int

log level

lines:String[]

lines to log

system:boolean

if lines should be written to jfr+event+system

Marks current chunk as final

This allows streaming clients to read the chunk header and close the stream when no more data will be written into the current repository.

Returns the same clock that sets the start time of a chunk (in nanos).

Create a new EventWriter

Returns:EventWriter

thread local EventWriter

Registers stack filters that should be used with getStackTrace(int, long)

Method name at an array index is for class at the same array index.

This method should be called holding the MetadataRepository lock and before bytecode for the associated event class has been added.

Returns:long

an ID that can be used to unregister the start frames, or -1 if it could not be registered

Call to invoke event tagging and retransformation of the passed classes

Exceptions

IllegalStateException:

if wrong JVMTI phase.

Turn on/off compressed integers.

Parameters

compressed:boolean

true if compressed integers should be used, false otherwise.

Exceptions

IllegalStateException:

if state can't be changed.

Stores an EventConfiguration to the configuration field of an event class.

Parameters

eventClass:Class<? extends Event>

the class, not null

configuration:EventConfiguration

the configuration, may be null

Returns:boolean

if the field could be set

Set the fixed CPU time sampler period. Use setCPURate(double) if you want a fixed rate with an auto-adjusted period instead. Setting period to 0 turns off the CPU time sampler.

Parameters

periodNanos:long

the new fixed period in nanoseconds

Set the maximum event emission rate for the CPU time sampler Use setCPUPeriod(long) if you want a fixed sampling period instead. Setting rate to 0 turns off the CPU time sampler.

Parameters

rate:double

the new rate in events per second

Sets cutoff for event. Determines how long the event should be allowed to run. Long.MAXIMUM_VALUE = no limit

Parameters

eventTypeId:long

the id of the event type

cutoffTicks:long

cutoff in ticks,

Returns:boolean

true, if it could be set

Sets the path to emergency dump.

Enable event

Parameters

eventTypeId:long

event type id

enabled:boolean

enable event

Interval at which the JVM should notify on FILE_DELTA_CHANGE

Parameters

delta:long

number of bytes, reset after file rotation

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

Set the number of global buffers to use

Exceptions

IllegalArgumentException:

if count is not within a valid range

IllegalStateException:

if value can't be changed

Set size of a global buffer

Exceptions

IllegalArgumentException:

if buffer size is not within a valid range

Set overall memory size

Exceptions

IllegalArgumentException:

if memory size is not within a valid range

Set period for method samples, in milliseconds. Setting period to 0 turns off the method sampler.

Parameters

periodMillis:long

the sampling period

Sets method tracing filters. A filter can be a class, a method, or an annotation. For example, the following three filters:

• Method timing on all methods in class com.foo.Bar
• Method tracing on the method com.foo.Bar::baz
• Method timing and tracing on all methods or classes with the annotation @com.foo.Foo

String[] classes = new String[3];
classes[0] = "com/foo/Bar";
classes[1] = "com/foo/Bar";
classes[2] = null;

String[] methods = new String[3];
methods[0] = null;
methods[1] = "baz";
methods[2] = null;

String[] annotations = new String[3];
annotations[0] = null;
annotations[1] = null;
annotations[2] = "com/foo/Foo";

int[] modifications = new int[3];
modifications[0] = 1; // filter should apply to timing
modifications[1] = 2; // filter should apply to tracing
modifications[2] = 1 | 2; // filter should apply to both timing and tracing

JVM.setMethodTraceFilters(classes, methods, annotations, modifications);

If a method is overloaded, the filter matches against all methods. It's not possible to match specific method parameters or annotation values.

Only one type of a filter - class, method, or annotation - can be used per array index.

If the filter is matched, JVMUpcalls::onMethodTrace will be invoked with the bytecode. If a filter is replaced, and method no longer requires instrumentation, the method will also be called with modification = 0;

Returns:long[]

the published IDs, or null if no classes has been published.

Sets bits used for event settings, like cutoff(ticks) and level

Parameters

eventTypeId:long

the id of the event type

Sets the file where data should be written. Requires that JFR has been started with JVMSupport#createJFR()

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()

Parameters

file:String

the file where data should be written, or null if it should not be copied out (in memory).

Sets the location of the disk repository.

Set stack depth.

Exceptions

IllegalArgumentException:

if not within a valid range

IllegalStateException:

if depth can't be changed

Turn on stack trace for an event

Parameters

eventTypeId:long

the event id

enabled:boolean

if stack traces should be enabled

Set thread buffer size.

Exceptions

IllegalArgumentException:

if size is not within a valid range

IllegalStateException:

if size can't be changed

Set threshold for event, Long.MAXIMUM_VALUE = no limit

Parameters

eventTypeId:long

the id of the event type

ticks:long

threshold in ticks,

Returns:boolean

true, if it could be set

Sets the event emission rate in event sample size per time unit. Determines how events are throttled.

Parameters

eventTypeId:long

the id of the event type

eventSampleSize:long

event sample size

period_ms:long

time period in milliseconds

Returns:boolean

true, if it could be set

Test if a chunk rotation is warranted.

Returns:boolean

if it is time to perform a chunk rotation

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 JVMSupport#createJFR()

Parameters

bytes:byte[]

binary representation of metadata descriptor

Subscribe to LogLevel updates for LogTag

Parameters

lt:LogTag

the log tag to subscribe

tagSetId:int

the tagset id

The tryUpdateEpoch() method(s) takes a state object as an argument and returns true if the epoch was exclusively updated by the current thread.

Parameters

root:Field

A java.lang.reflect.Field instance root, not null

Returns:boolean

true if the epoch was updated by the current thread.

Annotations

@IntrinsicCandidate

Unregisters a set of stack filters.

This method should be called holding the MetadataRepository lock and after the associated event class has been unloaded.

Parameters

stackFilterId:long

the stack filter ID to unregister