src/hotspot/share/jfr/recorder/repository/jfrEmergencyDump.cpp:

  if (exception_handler) {
    // we are crashing
    if (thread->is_Watcher_thread()) {
      // The Watcher thread runs the periodic thread sampling task.
      // If it has crashed, it is likely that another thread is
      // left in a suspended state. This would mean the system
      // will not be able to ever move to a safepoint. We try
      // to avoid issuing safepoint operations when attempting
      // an emergency dump, but a safepoint might be already pending.
      return;
    }
    prepare_for_emergency_dump(thread);
  }
  EventDumpReason event;
  if (event.should_commit()) {
    event.set_reason(exception_handler ? "Crash" : "Out of Memory");
    event.set_recordingId(-1);
    event.commit();
  }
  if (!exception_handler) {
    // OOM
    LeakProfiler::emit_events(max_jlong, false);
  }
  const int messages = MSGBIT(MSG_VM_ERROR);
  ResourceMark rm(thread);

src/hotspot/share/jfr/recorder/storage/jfrStorage.cpp:

      assert(!buffer->transient(), "invariant");
      assert(buffer->lease(), "invariant");
      storage_instance.control().increment_leased();
      return buffer;
    }
  }
  return acquire_transient(size, thread);
}

static void write_data_loss_event(JfrBuffer* buffer, u8 unflushed_size, Thread* thread) {
  assert(buffer != NULL, "invariant");
  assert(buffer->empty(), "invariant");
  const u8 total_data_loss = thread->jfr_thread_local()->add_data_lost(unflushed_size);
  if (EventDataLoss::is_enabled()) {
    JfrNativeEventWriter writer(buffer, thread);
    writer.write<u8>(EventDataLoss::eventId);
    writer.write(JfrTicks::now());
    writer.write(unflushed_size);
    writer.write(total_data_loss);
  }
}

static void write_data_loss(BufferPtr buffer, Thread* thread) {
  assert(buffer != NULL, "invariant");
  const size_t unflushed_size = buffer->unflushed_size();
  buffer->concurrent_reinitialization();
  if (unflushed_size == 0) {

src/jdk.jfr/share/classes/jdk/jfr/events/ActiveRecordingEvent.java:

@Name(Type.EVENT_NAME_PREFIX + "ActiveRecording")
@Label("Flight Recording")
@Category("Flight Recorder")
@StackTrace(false)
public final class ActiveRecordingEvent extends AbstractJDKEvent {

    @Label("Id")
    public long id;

    @Label("Name")
    public String name;

    @Label("Destination")
    public String destination;

    @Label("Max Age")

src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java:

    private long recordingCounter = 0;
    private RepositoryChunk currentChunk;

    public PlatformRecorder() throws Exception {
        repository = Repository.getRepository();
        Logger.log(JFR_SYSTEM, INFO, "Initialized disk repository");
        repository.ensureRepository();
        jvm.createNativeJFR();
        Logger.log(JFR_SYSTEM, INFO, "Created native");
        JDKEvents.initialize();
        Logger.log(JFR_SYSTEM, INFO, "Registered JDK events");
        JDKEvents.addInstrumentation();
        startDiskMonitor();
        activeRecordingEvent = EventType.getEventType(ActiveRecordingEvent.class);
        activeSettingEvent = EventType.getEventType(ActiveSettingEvent.class);
        shutdownHook = SecuritySupport.createThreadWitNoPermissions("JFR: Shutdown Hook", new ShutdownHook(this));
        SecuritySupport.setUncaughtExceptionHandler(shutdownHook, new ShutdownHook.ExceptionHandler());
        SecuritySupport.registerShutdownHook(shutdownHook);
        timer = createTimer();
    }


    private static Timer createTimer() {
        try {
            List<Timer> result = new CopyOnWriteArrayList<>();

src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java:

        chunk.finish(time);
        for (PlatformRecording r : getRecordings()) {
            if (r != ignoreMe && r.getState() == RecordingState.RUNNING) {
                r.appendChunk(chunk);
            }
        }
    }

    private void writeMetaEvents() {

        if (activeRecordingEvent.isEnabled()) {
            for (PlatformRecording r : getRecordings()) {
                if (r.getState() == RecordingState.RUNNING && r.shouldWriteMetadataEvent()) {
                    ActiveRecordingEvent event = new ActiveRecordingEvent();
                    event.id = r.getId();
                    event.name = r.getName();
                    WriteableUserPath p = r.getDestination();
                    event.destination = p == null ? null : p.getRealPathText();
                    Duration d = r.getDuration();
                    event.recordingDuration = d == null ? Long.MAX_VALUE : d.toMillis();
                    Duration age = r.getMaxAge();
                    event.maxAge = age == null ? Long.MAX_VALUE : age.toMillis();
                    Long size = r.getMaxSize();
                    event.maxSize = size == null ? Long.MAX_VALUE : size;
                    Instant start = r.getStartTime();

src/jdk.jfr/share/classes/jdk/jfr/internal/instrument/JDKEvents.java:

        X509ValidationEvent.class
    };

    private static final Class<?>[] eventClasses = {
        FileForceEvent.class,
        FileReadEvent.class,
        FileWriteEvent.class,
        SocketReadEvent.class,
        SocketWriteEvent.class,
        ExceptionThrownEvent.class,
        ExceptionStatisticsEvent.class,
        ErrorThrownEvent.class,
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        jdk.internal.event.DeserializationEvent.class,
        jdk.internal.event.SecurityPropertyModificationEvent.class,
        jdk.internal.event.SecurityProviderServiceEvent.class,
        jdk.internal.event.TLSHandshakeEvent.class,
        jdk.internal.event.X509CertificateEvent.class,
        jdk.internal.event.X509ValidationEvent.class
    };

    // This is a list of the classes with instrumentation code that should be applied.
    private static final Class<?>[] instrumentationClasses = new Class<?>[] {
        FileInputStreamInstrumentor.class,

src/jdk.jfr/share/classes/jdk/jfr/events/ActiveSettingEvent.java:

package jdk.jfr.events;

import jdk.jfr.Category;
import jdk.jfr.Label;
import jdk.jfr.Name;
import jdk.jfr.StackTrace;
import jdk.jfr.internal.Type;

@Name(Type.EVENT_NAME_PREFIX + "ActiveSetting")
@Label("Recording Setting")
@Category("Flight Recorder")
@StackTrace(false)
public final class ActiveSettingEvent extends AbstractJDKEvent {

    @Label("Event Id")
    public long id;

    @Label("Setting Name")
    public String name;

    @Label("Setting Value")
    public String value;
}

src/jdk.jfr/share/classes/jdk/jfr/internal/EventControl.java:

    void writeActiveSettingEvent() {
        if (!type.isRegistered()) {
            return;
        }
        for (Map.Entry<String, Control> entry : eventControls.entrySet()) {
            Control c = entry.getValue();
            if (Utils.isSettingVisible(c, type.hasEventHook())) {
                String value = c.getLastValue();
                if (value == null) {
                    value = c.getDefaultValue();
                }
                ActiveSettingEvent ase = new ActiveSettingEvent();
                ase.id = type.getId();
                ase.name = entry.getKey();
                ase.value = value;
                ase.commit();
            }
        }
    }

    public Set<Entry<String, Control>> getEntries() {
        return eventControls.entrySet();
    }

src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java:

    private RepositoryChunk currentChunk;

    public PlatformRecorder() throws Exception {
        repository = Repository.getRepository();
        Logger.log(JFR_SYSTEM, INFO, "Initialized disk repository");
        repository.ensureRepository();
        jvm.createNativeJFR();
        Logger.log(JFR_SYSTEM, INFO, "Created native");
        JDKEvents.initialize();
        Logger.log(JFR_SYSTEM, INFO, "Registered JDK events");
        JDKEvents.addInstrumentation();
        startDiskMonitor();
        activeRecordingEvent = EventType.getEventType(ActiveRecordingEvent.class);
        activeSettingEvent = EventType.getEventType(ActiveSettingEvent.class);
        shutdownHook = SecuritySupport.createThreadWitNoPermissions("JFR: Shutdown Hook", new ShutdownHook(this));
        SecuritySupport.setUncaughtExceptionHandler(shutdownHook, new ShutdownHook.ExceptionHandler());
        SecuritySupport.registerShutdownHook(shutdownHook);
        timer = createTimer();
    }


    private static Timer createTimer() {
        try {
            List<Timer> result = new CopyOnWriteArrayList<>();
            Thread t = SecuritySupport.createThreadWitNoPermissions("Permissionless thread", ()-> {

src/jdk.jfr/share/classes/jdk/jfr/internal/instrument/JDKEvents.java:

        X509CertificateEvent.class,
        X509ValidationEvent.class
    };

    private static final Class<?>[] eventClasses = {
        FileForceEvent.class,
        FileReadEvent.class,
        FileWriteEvent.class,
        SocketReadEvent.class,
        SocketWriteEvent.class,
        ExceptionThrownEvent.class,
        ExceptionStatisticsEvent.class,
        ErrorThrownEvent.class,
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        jdk.internal.event.DeserializationEvent.class,
        jdk.internal.event.SecurityPropertyModificationEvent.class,
        jdk.internal.event.SecurityProviderServiceEvent.class,
        jdk.internal.event.TLSHandshakeEvent.class,
        jdk.internal.event.X509CertificateEvent.class,
        jdk.internal.event.X509ValidationEvent.class
    };

    // This is a list of the classes with instrumentation code that should be applied.
    private static final Class<?>[] instrumentationClasses = new Class<?>[] {

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

#if INCLUDE_SHENANDOAHGC
#include "gc/shenandoah/shenandoahJfrSupport.hpp"
#endif

/**
 *  JfrPeriodic class
 *  Implementation of declarations in
 *  xsl generated traceRequestables.hpp
 */
#define TRACE_REQUEST_FUNC(id)    void JfrPeriodicEventSet::request##id(void)

TRACE_REQUEST_FUNC(JVMInformation) {
  ResourceMark rm;
  EventJVMInformation event;
  event.set_jvmName(VM_Version::vm_name());
  event.set_jvmVersion(VM_Version::internal_vm_info_string());
  event.set_javaArguments(Arguments::java_command());
  event.set_jvmArguments(Arguments::jvm_args());
  event.set_jvmFlags(Arguments::jvm_flags());
  event.set_jvmStartTime(Management::vm_init_done_time());
  event.set_pid(os::current_process_id());
  event.commit();
 }

TRACE_REQUEST_FUNC(OSInformation) {

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

  jlong max_size = conf.has_max_size_default_value() ? jmc_undefined_long : conf.max_size();
  EventYoungGenerationConfiguration event;
  event.set_maxSize((u8)max_size);
  event.set_minSize(conf.min_size());
  event.set_newRatio(conf.new_ratio());
  event.commit();
}

TRACE_REQUEST_FUNC(InitialSystemProperty) {
  SystemProperty* p = Arguments::system_properties();
  JfrTicks time_stamp = JfrTicks::now();
  while (p !=  NULL) {
    if (!p->internal()) {
      EventInitialSystemProperty event(UNTIMED);
      event.set_key(p->key());
      event.set_value(p->value());
      event.set_endtime(time_stamp);
      event.commit();
    }
    p = p->next();
  }
}

TRACE_REQUEST_FUNC(ThreadAllocationStatistics) {
  ResourceMark rm;

src/hotspot/share/classfile/systemDictionary.cpp:

          SystemDictionary_lock->wait();
        } else {
          double_lock_wait(lockObject, THREAD);
        }
      } else {
        // If not in SD and not in PH, other thread's load must have failed
        super_load_in_progress = false;
      }
    }
  }
  return NULL;
}

static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld) {
  assert(event != NULL, "invariant");
  assert(k != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  event->set_loadedClass(k);
  event->set_definingClassLoader(k->class_loader_data());
  event->set_initiatingClassLoader(init_cld);
  event->commit();
}


// Be careful when modifying this code: once you have run
// placeholders()->find_and_add(PlaceholderTable::LOAD_INSTANCE),
// you need to find_and_remove it before returning.
// So be careful to not exit with a CHECK_ macro betweeen these calls.
Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
                                                        Handle class_loader,
                                                        Handle protection_domain,
                                                        TRAPS) {
  assert(name != NULL && !FieldType::is_array(name) &&
         !FieldType::is_obj(name), "invalid class name");

  EventClassLoad class_load_start_event;

  HandleMark hm(THREAD);

  // Fix for 4474172; see evaluation for more details
  class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
  ClassLoaderData* loader_data = register_loader(class_loader);
  Dictionary* dictionary = loader_data->dictionary();
  unsigned int d_hash = dictionary->compute_hash(name);

  // Do lookup to see if class already exist and the protection domain
  // has the right access

src/hotspot/share/classfile/systemDictionary.cpp:

// Note: this method is much like resolve_from_stream, but
// does not publish the classes via the SystemDictionary.
// Handles unsafe_DefineAnonymousClass and redefineclasses
// RedefinedClasses do not add to the class hierarchy
InstanceKlass* SystemDictionary::parse_stream(Symbol* class_name,
                                              Handle class_loader,
                                              Handle protection_domain,
                                              ClassFileStream* st,
                                              const InstanceKlass* host_klass,
                                              GrowableArray<Handle>* cp_patches,
                                              TRAPS) {

  EventClassLoad class_load_start_event;

  ClassLoaderData* loader_data;
  if (host_klass != NULL) {
    // Create a new CLD for anonymous class, that uses the same class loader
    // as the host_klass
    guarantee(host_klass->class_loader() == class_loader(), "should be the same");
    loader_data = ClassLoaderData::anonymous_class_loader_data(class_loader);
  } else {
    loader_data = ClassLoaderData::class_loader_data(class_loader());
  }

src/hotspot/share/classfile/systemDictionary.cpp:

      // For user defined Java class loaders, check that the name returned is
      // the same as that requested.  This check is done for the bootstrap
      // loader when parsing the class file.
      if (class_name == k->name()) {
        return k;
      }
    }
    // Class is not found or has the wrong name, return NULL
    return NULL;
  }
}

static void post_class_define_event(InstanceKlass* k, const ClassLoaderData* def_cld) {
  EventClassDefine event;
  if (event.should_commit()) {
    event.set_definedClass(k);
    event.set_definingClassLoader(def_cld);
    event.commit();
  }
}

void SystemDictionary::define_instance_class(InstanceKlass* k, TRAPS) {

  HandleMark hm(THREAD);
  ClassLoaderData* loader_data = k->class_loader_data();

src/hotspot/share/classfile/classLoaderData.cpp:

    for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
      if (loader_data == data) {
        return true;
      }
    }
  }
  return false;
}

#if INCLUDE_JFR
static Ticks class_unload_time;
static void post_class_unload_event(Klass* const k) {
  assert(k != NULL, "invariant");
  EventClassUnload event(UNTIMED);
  event.set_endtime(class_unload_time);
  event.set_unloadedClass(k);
  event.set_definingClassLoader(k->class_loader_data());
  event.commit();
}

static void post_class_unload_events() {
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
  if (Jfr::is_enabled()) {
    if (EventClassUnload::is_enabled()) {
      class_unload_time = Ticks::now();
      ClassLoaderDataGraph::classes_unloading_do(&post_class_unload_event);
    }
    Jfr::on_unloading_classes();
  }
}
#endif // INCLUDE_JFR

// Move class loader data from main list to the unloaded list for unloading
// and deallocation later.
bool ClassLoaderDataGraph::do_unloading(bool clean_previous_versions) {

src/hotspot/share/code/codeCache.cpp:

    {
      ttyLocker ttyl;
      tty->print("%s", s.as_string());
    }

    if (heap->full_count() == 1) {
      LogTarget(Debug, codecache) lt;
      if (lt.is_enabled()) {
        CompileBroker::print_heapinfo(tty, "all", 4096); // details, may be a lot!
      }
    }
  }

  EventCodeCacheFull event;
  if (event.should_commit()) {
    event.set_codeBlobType((u1)code_blob_type);
    event.set_startAddress((u8)heap->low_boundary());
    event.set_commitedTopAddress((u8)heap->high());
    event.set_reservedTopAddress((u8)heap->high_boundary());
    event.set_entryCount(heap->blob_count());
    event.set_methodCount(heap->nmethod_count());
    event.set_adaptorCount(heap->adapter_count());
    event.set_unallocatedCapacity(heap->unallocated_capacity());
    event.set_fullCount(heap->full_count());
    event.commit();

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

TRACE_REQUEST_FUNC(CompilerConfiguration) {
  EventCompilerConfiguration event;
  event.set_threadCount(CICompilerCount);
  event.set_tieredCompilation(TieredCompilation);
  event.commit();
}

TRACE_REQUEST_FUNC(CodeCacheStatistics) {
  // Emit stats for all available code heaps
  for (int bt = 0; bt < CodeBlobType::NumTypes; ++bt) {
    if (CodeCache::heap_available(bt)) {
      EventCodeCacheStatistics event;
      event.set_codeBlobType((u1)bt);
      event.set_startAddress((u8)CodeCache::low_bound(bt));
      event.set_reservedTopAddress((u8)CodeCache::high_bound(bt));
      event.set_entryCount(CodeCache::blob_count(bt));
      event.set_methodCount(CodeCache::nmethod_count(bt));
      event.set_adaptorCount(CodeCache::adapter_count(bt));
      event.set_unallocatedCapacity(CodeCache::unallocated_capacity(bt));
      event.set_fullCount(CodeCache::get_codemem_full_count(bt));
      event.commit();
    }
  }

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

      event.set_startAddress((u8)CodeCache::low_bound(bt));
      event.set_reservedTopAddress((u8)CodeCache::high_bound(bt));
      event.set_entryCount(CodeCache::blob_count(bt));
      event.set_methodCount(CodeCache::nmethod_count(bt));
      event.set_adaptorCount(CodeCache::adapter_count(bt));
      event.set_unallocatedCapacity(CodeCache::unallocated_capacity(bt));
      event.set_fullCount(CodeCache::get_codemem_full_count(bt));
      event.commit();
    }
  }
}

TRACE_REQUEST_FUNC(CodeCacheConfiguration) {
  EventCodeCacheConfiguration event;
  event.set_initialSize(InitialCodeCacheSize);
  event.set_reservedSize(ReservedCodeCacheSize);
  event.set_nonNMethodSize(NonNMethodCodeHeapSize);
  event.set_profiledSize(ProfiledCodeHeapSize);
  event.set_nonProfiledSize(NonProfiledCodeHeapSize);
  event.set_expansionSize(CodeCacheExpansionSize);
  event.set_minBlockLength(CodeCacheMinBlockLength);
  event.set_startAddress((u8)CodeCache::low_bound());
  event.set_reservedTopAddress((u8)CodeCache::high_bound());
  event.commit();
}

src/hotspot/share/runtime/sweeper.cpp:

  if (_should_sweep) {
    _bytes_changed = 0;
  }

  if (forced) {
    // Notify requester that forced sweep finished
    assert(_force_sweep, "Should be a forced sweep");
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
    _force_sweep = false;
    CodeCache_lock->notify();
  }
}

static void post_sweep_event(EventSweepCodeCache* event,
                             const Ticks& start,
                             const Ticks& end,
                             s4 traversals,
                             int swept,
                             int flushed,
                             int zombified) {
  assert(event != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  event->set_starttime(start);
  event->set_endtime(end);
  event->set_sweepId(traversals);

src/hotspot/share/runtime/sweeper.cpp:

  const Ticks sweep_end_counter = Ticks::now();
  const Tickspan sweep_time = sweep_end_counter - sweep_start_counter;
  {
    MutexLockerEx mu(NMethodSweeperStats_lock, Mutex::_no_safepoint_check_flag);
    _total_time_sweeping  += sweep_time;
    _total_time_this_sweep += sweep_time;
    _peak_sweep_fraction_time = MAX2(sweep_time, _peak_sweep_fraction_time);
    _total_flushed_size += freed_memory;
    _total_nof_methods_reclaimed += flushed_count;
    _total_nof_c2_methods_reclaimed += flushed_c2_count;
    _peak_sweep_time = MAX2(_peak_sweep_time, _total_time_this_sweep);
  }

  EventSweepCodeCache event(UNTIMED);
  if (event.should_commit()) {
    post_sweep_event(&event, sweep_start_counter, sweep_end_counter, (s4)_traversals, swept_count, flushed_count, zombified_count);
  }

#ifdef ASSERT
  if(PrintMethodFlushing) {
    tty->print_cr("### sweeper:      sweep time(" JLONG_FORMAT "): ", sweep_time.value());
  }
#endif

  Log(codecache, sweep) log;

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

  event.set_initialSize(InitialCodeCacheSize);
  event.set_reservedSize(ReservedCodeCacheSize);
  event.set_nonNMethodSize(NonNMethodCodeHeapSize);
  event.set_profiledSize(ProfiledCodeHeapSize);
  event.set_nonProfiledSize(NonProfiledCodeHeapSize);
  event.set_expansionSize(CodeCacheExpansionSize);
  event.set_minBlockLength(CodeCacheMinBlockLength);
  event.set_startAddress((u8)CodeCache::low_bound());
  event.set_reservedTopAddress((u8)CodeCache::high_bound());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperStatistics) {
  EventCodeSweeperStatistics event;
  event.set_sweepCount(NMethodSweeper::traversal_count());
  event.set_methodReclaimedCount(NMethodSweeper::total_nof_methods_reclaimed());
  event.set_totalSweepTime(NMethodSweeper::total_time_sweeping());
  event.set_peakFractionTime(NMethodSweeper::peak_sweep_fraction_time());
  event.set_peakSweepTime(NMethodSweeper::peak_sweep_time());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperConfiguration) {
  EventCodeSweeperConfiguration event;
  event.set_sweeperEnabled(MethodFlushing);

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp:

TRACE_REQUEST_FUNC(CodeSweeperStatistics) {
  EventCodeSweeperStatistics event;
  event.set_sweepCount(NMethodSweeper::traversal_count());
  event.set_methodReclaimedCount(NMethodSweeper::total_nof_methods_reclaimed());
  event.set_totalSweepTime(NMethodSweeper::total_time_sweeping());
  event.set_peakFractionTime(NMethodSweeper::peak_sweep_fraction_time());
  event.set_peakSweepTime(NMethodSweeper::peak_sweep_time());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperConfiguration) {
  EventCodeSweeperConfiguration event;
  event.set_sweeperEnabled(MethodFlushing);
  event.set_flushingEnabled(UseCodeCacheFlushing);
  event.commit();
}

TRACE_REQUEST_FUNC(ShenandoahHeapRegionInformation) {
#if INCLUDE_SHENANDOAHGC
  if (UseShenandoahGC) {
    VM_ShenandoahSendHeapRegionInfoEvents op;
    VMThread::execute(&op);
  }

src/hotspot/share/compiler/compileBroker.cpp:

  } else if (AbortVMOnCompilationFailure) {
    if (compilable == ciEnv::MethodCompilable_not_at_tier) {
      fatal("Not compilable at tier %d: %s", task->comp_level(), failure_reason);
    }
    if (compilable == ciEnv::MethodCompilable_never) {
      fatal("Never compilable: %s", failure_reason);
    }
  }
  // simulate crash during compilation
  assert(task->compile_id() != CICrashAt, "just as planned");
}

static void post_compilation_event(EventCompilation* event, CompileTask* task) {
  assert(event != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  event->set_method(task->method());
  event->set_compileId(task->compile_id());
  event->set_compileLevel(task->comp_level());
  event->set_succeded(task->is_success());
  event->set_isOsr(task->osr_bci() != CompileBroker::standard_entry_bci);
  event->set_codeSize((task->code() == NULL) ? 0 : task->code()->total_size());
  event->set_inlinedBytes(task->num_inlined_bytecodes());
  event->commit();
}

src/hotspot/share/compiler/compileBroker.cpp:

  // Allocate a new set of JNI handles.
  push_jni_handle_block();
  Method* target_handle = task->method();
  int compilable = ciEnv::MethodCompilable;
  const char* failure_reason = NULL;
  const char* retry_message = NULL;

#if INCLUDE_JVMCI
  if (UseJVMCICompiler && comp != NULL && comp->is_jvmci()) {
    JVMCICompiler* jvmci = (JVMCICompiler*) comp;

    TraceTime t1("compilation", &time);
    EventCompilation event;

    // Skip redefined methods
    if (target_handle->is_old()) {
        failure_reason = "redefined method";
        retry_message = "not retryable";
        compilable = ciEnv::MethodCompilable_never;
    } else {
        JVMCIEnv env(task);
        methodHandle method(thread, target_handle);
        jvmci->compile_method(method, osr_bci, &env);

src/hotspot/share/compiler/compileBroker.cpp:

    assert(thread->env() == &ci_env, "set by ci_env");
    // The thread-env() field is cleared in ~CompileTaskWrapper.

    // Cache Jvmti state
    ci_env.cache_jvmti_state();

    // Cache DTrace flags
    ci_env.cache_dtrace_flags();

    ciMethod* target = ci_env.get_method_from_handle(target_handle);

    TraceTime t1("compilation", &time);
    EventCompilation event;

    if (comp == NULL) {
      ci_env.record_method_not_compilable("no compiler", !TieredCompilation);
    } else {
      if (WhiteBoxAPI && WhiteBox::compilation_locked) {
        MonitorLockerEx locker(Compilation_lock, Mutex::_no_safepoint_check_flag);
        while (WhiteBox::compilation_locked) {
          locker.wait(Mutex::_no_safepoint_check_flag);
        }
      }
      comp->compile_method(&ci_env, target, osr_bci, directive);

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EmptyEventProvider.java:

package jdk.vm.ci.hotspot;

/**
 * An empty implementation for {@link EventProvider}. This implementation is used when no logging is
 * requested.
 */
final class EmptyEventProvider implements EventProvider {

    static InternalError shouldNotReachHere() {
        throw new InternalError("should not reach here");
    }

    @Override
    public CompilationEvent newCompilationEvent() {
        return new EmptyCompilationEvent();
    }

    static class EmptyCompilationEvent implements CompilationEvent {
        @Override
        public void commit() {
            throw shouldNotReachHere();
        }

        @Override
        public boolean shouldWrite() {
            // Events of this class should never been written.
            return false;
        }

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EventProvider.java:

 * Service-provider class for logging compiler related events.
 */
public interface EventProvider {

    /**
     * Creates and returns an empty implementation for {@link EventProvider}. This implementation
     * can be used when no logging is requested.
     */
    static EventProvider createEmptyEventProvider() {
        return new EmptyEventProvider();
    }

    /**
     * Creates and returns an empty implementation for {@link CompilationEvent}.
     */
    static CompilationEvent createEmptyCompilationEvent() {
        return new EmptyCompilationEvent();
    }

    /**
     * Creates and returns an empty implementation for {@link CompilationEvent}.
     */
    static CompilerFailureEvent createEmptyCompilerFailureEvent() {
        return new EmptyCompilerFailureEvent();
    }

    /**
     * An instant event is an event that is not considered to have taken any time.
     */
    public interface InstantEvent {
        /**
         * Commits the event.

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EventProvider.java:

    public interface TimedEvent extends InstantEvent {
        /**
         * Starts the timing for this event.
         */
        void begin();

        /**
         * Ends the timing period for this event.
         */
        void end();
    }

    /**
     * Creates a new {@link CompilationEvent}.
     *
     * @return a compilation event
     */
    public abstract CompilationEvent newCompilationEvent();

    /**
     * A compilation event.
     */
    public interface CompilationEvent extends TimedEvent {
        void setMethod(String method);

        void setCompileId(int compileId);

        void setCompileLevel(int compileLevel);

        void setSucceeded(boolean succeeded);

        void setIsOsr(boolean isOsr);

        void setCodeSize(int codeSize);

src/hotspot/share/opto/compile.hpp:

    bool need = directive()->IGVPrintLevelOption >= level;
    if (need && !_printer) {
      _printer = IdealGraphPrinter::printer();
      assert(_printer != NULL, "_printer is NULL when we need it!");
      _printer->set_compile(this);
    }
    return need;
#else
    return false;
#endif
  }

  void print_method(CompilerPhaseType cpt, int level = 1) {
    EventCompilerPhase event;
    if (event.should_commit()) {
      event.set_starttime(C->_latest_stage_start_counter);
      event.set_phase((u1) cpt);
      event.set_compileId(C->_compile_id);
      event.set_phaseLevel(level);
      event.commit();
    }


#ifndef PRODUCT
    if (_printer && should_print(level)) {
      _printer->print_method(CompilerPhaseTypeHelper::to_string(cpt), level);
    }
#endif
    C->_latest_stage_start_counter.stamp();
  }

  void end_method(int level = 1) {
    EventCompilerPhase event;
    if (event.should_commit()) {
      event.set_starttime(C->_latest_stage_start_counter);
      event.set_phase((u1) PHASE_END);
      event.set_compileId(C->_compile_id);
      event.set_phaseLevel(level);
      event.commit();
    }
#ifndef PRODUCT
    if (_printer && should_print(level)) {
      _printer->end_method();
    }

src/hotspot/share/ci/ciEnv.cpp:

// ------------------------------------------------------------------
// ciEnv::record_failure()
void ciEnv::record_failure(const char* reason) {
  if (_failure_reason == NULL) {
    // Record the first failure reason.
    _failure_reason = reason;
  }
}

void ciEnv::report_failure(const char* reason) {
  EventCompilationFailure event;
  if (event.should_commit()) {
    event.set_compileId(compile_id());
    event.set_failureMessage(reason);
    event.commit();
  }
}

// ------------------------------------------------------------------
// ciEnv::record_method_not_compilable()
void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
  int new_compilable =

src/hotspot/share/opto/bytecodeInfo.cpp:

const char* InlineTree::check_can_parse(ciMethod* callee) {
  // Certain methods cannot be parsed at all:
  if ( callee->is_native())                     return "native method";
  if ( callee->is_abstract())                   return "abstract method";
  if (!callee->has_balanced_monitors())         return "not compilable (unbalanced monitors)";
  if ( callee->get_flow_analysis()->failing())  return "not compilable (flow analysis failed)";
  if (!callee->can_be_parsed())                 return "cannot be parsed";
  return NULL;
}

static void post_inlining_event(int compile_id,const char* msg, bool success, int bci, ciMethod* caller, ciMethod* callee) {
  assert(caller != NULL, "invariant");
  assert(callee != NULL, "invariant");
  EventCompilerInlining event;
  if (event.should_commit()) {
    JfrStructCalleeMethod callee_struct;
    callee_struct.set_type(callee->holder()->name()->as_utf8());
    callee_struct.set_name(callee->name()->as_utf8());
    callee_struct.set_descriptor(callee->signature()->as_symbol()->as_utf8());
    event.set_compileId(compile_id);
    event.set_message(msg);
    event.set_succeeded(success);
    event.set_bci(bci);
    event.set_caller(caller->get_Method());
    event.set_callee(callee_struct);

src/hotspot/share/c1/c1_GraphBuilder.cpp:

  Value index = args->at(1);
  if (is_store) {
    Value value = args->at(2);
    Instruction* store = append(new StoreIndexed(array, index, NULL, T_CHAR, value, state_before, false, true));
    store->set_flag(Instruction::NeedsRangeCheckFlag, false);
    _memory->store_value(value);
  } else {
    Instruction* load = append(new LoadIndexed(array, index, NULL, T_CHAR, state_before, true));
    load->set_flag(Instruction::NeedsRangeCheckFlag, false);
    push(load->type(), load);
  }
}

static void post_inlining_event(EventCompilerInlining* event,
                                int compile_id,
                                const char* msg,
                                bool success,
                                int bci,
                                ciMethod* caller,
                                ciMethod* callee) {
  assert(caller != NULL, "invariant");
  assert(callee != NULL, "invariant");
  assert(event != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  JfrStructCalleeMethod callee_struct;

src/hotspot/share/c1/c1_GraphBuilder.cpp:

  event->commit();
}

void GraphBuilder::print_inlining(ciMethod* callee, const char* msg, bool success) {
  CompileLog* log = compilation()->log();
  if (log != NULL) {
    assert(msg != NULL, "inlining msg should not be null!");
    if (success) {
      log->inline_success(msg);
    } else {
      log->inline_fail(msg);
    }
  }
  EventCompilerInlining event;
  if (event.should_commit()) {
    post_inlining_event(&event, compilation()->env()->task()->compile_id(), msg, success, bci(), method(), callee);
  }

  CompileTask::print_inlining_ul(callee, scope()->level(), bci(), msg);

  if (!compilation()->directive()->PrintInliningOption) {
    return;
  }
  CompileTask::print_inlining_tty(callee, scope()->level(), bci(), msg);
  if (success && CIPrintMethodCodes) {