jdk8-mips64-public/hotspot: src/share/vm/jfr/recorder/checkpoint/types/jfrType.cpp@8e875c964f41

8214542: JFR: Old Object Sample event slow on a deep heap in debug builds
Reviewed-by: egahlin, rwestberg

     1 /*

     2  * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    25 #include "precompiled.hpp"

    26 #include "classfile/javaClasses.hpp"

    27 #include "code/codeBlob.hpp"

    28 #include "code/codeCache.hpp"

    29 #include "gc_interface/gcCause.hpp"

    30 #include "gc_interface/gcName.hpp"

    31 #include "gc_implementation/shared/gcTrace.hpp"

    32 #include "gc_implementation/shared/gcWhen.hpp"

    33 #include "jfr/leakprofiler/checkpoint/objectSampleCheckpoint.hpp"

    34 #include "jfr/leakprofiler/leakProfiler.hpp"

    35 #include "jfr/recorder/checkpoint/jfrCheckpointManager.hpp"

    36 #include "jfr/recorder/checkpoint/types/jfrType.hpp"

    37 #include "jfr/recorder/jfrRecorder.hpp"

    38 #include "jfr/recorder/checkpoint/types/jfrThreadGroup.hpp"

    39 #include "jfr/recorder/checkpoint/types/jfrThreadState.hpp"

    40 #include "jfr/recorder/checkpoint/types/jfrTypeSet.hpp"

    41 #include "jfr/support/jfrThreadLocal.hpp"

    42 #include "jfr/writers/jfrJavaEventWriter.hpp"

    43 #include "memory/metaspaceGCThresholdUpdater.hpp"

    44 #include "memory/referenceType.hpp"

    45 #include "memory/universe.hpp"

    46 #include "runtime/mutexLocker.hpp"

    47 #include "runtime/osThread.hpp"

    48 #include "runtime/safepoint.hpp"

    49 #include "runtime/synchronizer.hpp"

    50 #include "runtime/thread.inline.hpp"

    51 #include "runtime/vm_operations.hpp"

    53 #ifdef COMPILER2

    54 #include "opto/compile.hpp"

    55 #include "opto/node.hpp"

    56 #endif

    57 #if INCLUDE_ALL_GCS

    58 #include "gc_implementation/g1/g1HeapRegionTraceType.hpp"

    59 #include "gc_implementation/g1/g1YCTypes.hpp"

    60 #endif

    62 // Requires a ResourceMark for get_thread_name/as_utf8

    63 class JfrCheckpointThreadClosure : public ThreadClosure {

    64  private:

    65   JfrCheckpointWriter& _writer;

    66   JfrCheckpointContext _ctx;

    67   const intptr_t _count_position;

    68   Thread* const _curthread;

    69   u4 _count;

    71  public:

    72   JfrCheckpointThreadClosure(JfrCheckpointWriter& writer) : _writer(writer),

    73                                                             _ctx(writer.context()),

    74                                                             _count_position(writer.reserve(sizeof(u4))),

    75                                                             _curthread(Thread::current()),

    76                                                             _count(0) {

    77   }

    79   ~JfrCheckpointThreadClosure() {

    80     if (_count == 0) {

    81       // restore

    82       _writer.set_context(_ctx);

    83       return;

    84     }

    85     _writer.write_count(_count, _count_position);

    86   }

    88   void do_thread(Thread* t);

    89 };

    91 // Requires a ResourceMark for get_thread_name/as_utf8

    92 void JfrCheckpointThreadClosure::do_thread(Thread* t) {

    93   assert(t != NULL, "invariant");

    94   assert_locked_or_safepoint(Threads_lock);

    95   const JfrThreadLocal* const tl = t->jfr_thread_local();

    96   assert(tl != NULL, "invariant");

    97   if (tl->is_dead()) {

    98     return;

    99   }

   100   ++_count;

   101   _writer.write_key(tl->thread_id());

   102   _writer.write(t->name());

   103   const OSThread* const os_thread = t->osthread();

   104   _writer.write<traceid>(os_thread != NULL ? os_thread->thread_id() : 0);

   105   if (t->is_Java_thread()) {

   106     JavaThread* const jt = (JavaThread*)t;

   107     _writer.write(jt->name());

   108     _writer.write(java_lang_Thread::thread_id(jt->threadObj()));

   109     _writer.write(JfrThreadGroup::thread_group_id(jt, _curthread));

   110     // since we are iterating threads during a safepoint, also issue notification

   111     JfrJavaEventWriter::notify(jt);

   112     return;

   113   }

   114   _writer.write((const char*)NULL); // java name

   115   _writer.write((traceid)0); // java thread id

   116   _writer.write((traceid)0); // java thread group

   117 }

   119 void JfrThreadConstantSet::serialize(JfrCheckpointWriter& writer) {

   120   assert(SafepointSynchronize::is_at_safepoint(), "invariant");

   121   JfrCheckpointThreadClosure tc(writer);

   122   Threads::threads_do(&tc);

   123 }

   125 void JfrThreadGroupConstant::serialize(JfrCheckpointWriter& writer) {

   126   assert(SafepointSynchronize::is_at_safepoint(), "invariant");

   127   JfrThreadGroup::serialize(writer);

   128 }

   130 static const char* flag_value_origin_to_string(Flag::Flags origin) {

   131   switch (origin) {

   132     case Flag::DEFAULT: return "Default";

   133     case Flag::COMMAND_LINE: return "Command line";

   134     case Flag::ENVIRON_VAR: return "Environment variable";

   135     case Flag::CONFIG_FILE: return "Config file";

   136     case Flag::MANAGEMENT: return "Management";

   137     case Flag::ERGONOMIC: return "Ergonomic";

   138     case Flag::ATTACH_ON_DEMAND: return "Attach on demand";

   139     case Flag::INTERNAL: return "Internal";

   140     default: ShouldNotReachHere(); return "";

   141   }

   142 }

   144 void FlagValueOriginConstant::serialize(JfrCheckpointWriter& writer) {

   145   static const u4 nof_entries = Flag::LAST_VALUE_ORIGIN + 1;

   146   writer.write_count(nof_entries);

   147   for (u4 i = 0; i < nof_entries; ++i) {

   148     writer.write_key(i);

   149     writer.write(flag_value_origin_to_string((Flag::Flags)i));

   150   }

   151 }

   153 void MonitorInflateCauseConstant::serialize(JfrCheckpointWriter& writer) {

   154   // XXX no such counters. implement?

   155 //  static const u4 nof_entries = ObjectSynchronizer::inflate_cause_nof;

   156 //  writer.write_count(nof_entries);

   157 //  for (u4 i = 0; i < nof_entries; ++i) {

   158 //    writer.write_key(i);

   159 //    writer.write(ObjectSynchronizer::inflate_cause_name((ObjectSynchronizer::InflateCause)i));

   160 //  }

   161 }

   163 void GCCauseConstant::serialize(JfrCheckpointWriter& writer) {

   164   static const u4 nof_entries = GCCause::_last_gc_cause;

   165   writer.write_count(nof_entries);

   166   for (u4 i = 0; i < nof_entries; ++i) {

   167     writer.write_key(i);

   168     writer.write(GCCause::to_string((GCCause::Cause)i));

   169   }

   170 }

   172 void GCNameConstant::serialize(JfrCheckpointWriter& writer) {

   173   static const u4 nof_entries = GCNameEndSentinel;

   174   writer.write_count(nof_entries);

   175   for (u4 i = 0; i < nof_entries; ++i) {

   176     writer.write_key(i);

   177     writer.write(GCNameHelper::to_string((GCName)i));

   178   }

   179 }

   181 void GCWhenConstant::serialize(JfrCheckpointWriter& writer) {

   182   static const u4 nof_entries = GCWhen::GCWhenEndSentinel;

   183   writer.write_count(nof_entries);

   184   for (u4 i = 0; i < nof_entries; ++i) {

   185     writer.write_key(i);

   186     writer.write(GCWhen::to_string((GCWhen::Type)i));

   187   }

   188 }

   190 void G1HeapRegionTypeConstant::serialize(JfrCheckpointWriter& writer) {

   191   static const u4 nof_entries = G1HeapRegionTraceType::G1HeapRegionTypeEndSentinel;

   192   writer.write_count(nof_entries);

   193   for (u4 i = 0; i < nof_entries; ++i) {

   194     writer.write_key(i);

   195     writer.write(G1HeapRegionTraceType::to_string((G1HeapRegionTraceType::Type)i));

   196   }

   197 }

   199 void GCThresholdUpdaterConstant::serialize(JfrCheckpointWriter& writer) {

   200   static const u4 nof_entries = MetaspaceGCThresholdUpdater::Last;

   201   writer.write_count(nof_entries);

   202   for (u4 i = 0; i < nof_entries; ++i) {

   203     writer.write_key(i);

   204     writer.write(MetaspaceGCThresholdUpdater::to_string((MetaspaceGCThresholdUpdater::Type)i));

   205   }

   206 }

   208 void MetadataTypeConstant::serialize(JfrCheckpointWriter& writer) {

   209   static const u4 nof_entries = Metaspace::MetadataTypeCount;

   210   writer.write_count(nof_entries);

   211   for (u4 i = 0; i < nof_entries; ++i) {

   212     writer.write_key(i);

   213     writer.write(Metaspace::metadata_type_name((Metaspace::MetadataType)i));

   214   }

   215 }

   217 void MetaspaceObjectTypeConstant::serialize(JfrCheckpointWriter& writer) {

   218   static const u4 nof_entries = MetaspaceObj::_number_of_types;

   219   writer.write_count(nof_entries);

   220   for (u4 i = 0; i < nof_entries; ++i) {

   221     writer.write_key(i);

   222     writer.write(MetaspaceObj::type_name((MetaspaceObj::Type)i));

   223   }

   224 }

   226 void G1YCTypeConstant::serialize(JfrCheckpointWriter& writer) {

   227 #if INCLUDE_ALL_GCS

   228   static const u4 nof_entries = G1YCTypeEndSentinel;

   229   writer.write_count(nof_entries);

   230   for (u4 i = 0; i < nof_entries; ++i) {

   231     writer.write_key(i);

   232     writer.write(G1YCTypeHelper::to_string((G1YCType)i));

   233   }

   234 #endif

   235 }

   237 static const char* reference_type_to_string(ReferenceType rt) {

   238   switch (rt) {

   239     case REF_NONE: return "None reference";

   240     case REF_OTHER: return "Other reference";

   241     case REF_SOFT: return "Soft reference";

   242     case REF_WEAK: return "Weak reference";

   243     case REF_FINAL: return "Final reference";

   244     case REF_PHANTOM: return "Phantom reference";

   245     default:

   246       ShouldNotReachHere();

   247     return NULL;

   248   }

   249 }

   251 void ReferenceTypeConstant::serialize(JfrCheckpointWriter& writer) {

   252   static const u4 nof_entries = REF_PHANTOM + 1;

   253   writer.write_count(nof_entries);

   254   for (u4 i = 0; i < nof_entries; ++i) {

   255     writer.write_key(i);

   256     writer.write(reference_type_to_string((ReferenceType)i));

   257   }

   258 }

   260 void NarrowOopModeConstant::serialize(JfrCheckpointWriter& writer) {

   261   static const u4 nof_entries = Universe::HeapBasedNarrowOop + 1;

   262   writer.write_count(nof_entries);

   263   for (u4 i = 0; i < nof_entries; ++i) {

   264     writer.write_key(i);

   265     writer.write(Universe::narrow_oop_mode_to_string((Universe::NARROW_OOP_MODE)i));

   266   }

   267 }

   269 void CompilerPhaseTypeConstant::serialize(JfrCheckpointWriter& writer) {

   270 #ifdef COMPILER2

   271   static const u4 nof_entries = PHASE_NUM_TYPES;

   272   writer.write_count(nof_entries);

   273   for (u4 i = 0; i < nof_entries; ++i) {

   274     writer.write_key(i);

   275     writer.write(CompilerPhaseTypeHelper::to_string((CompilerPhaseType)i));

   276   }

   277 #endif

   278 }

   280 void CodeBlobTypeConstant::serialize(JfrCheckpointWriter& writer) {

   281   static const u4 nof_entries = CodeBlobType::NumTypes;

   282   writer.write_count(nof_entries);

   283   writer.write_key((u4)CodeBlobType::All);

   284   writer.write("CodeCache");

   285 };

   287 void VMOperationTypeConstant::serialize(JfrCheckpointWriter& writer) {

   288   static const u4 nof_entries = VM_Operation::VMOp_Terminating;

   289   writer.write_count(nof_entries);

   290   for (u4 i = 0; i < nof_entries; ++i) {

   291     writer.write_key(i);

   292     writer.write(VM_Operation::name(VM_Operation::VMOp_Type(i)));

   293   }

   294 }

   296 class TypeSetSerialization {

   297  private:

   298   bool _class_unload;

   299  public:

   300   explicit TypeSetSerialization(bool class_unload) : _class_unload(class_unload) {}

   301   void write(JfrCheckpointWriter& writer, JfrCheckpointWriter* leakp_writer) {

   302     JfrTypeSet::serialize(&writer, leakp_writer, _class_unload);

   303   }

   304 };

   306 void ClassUnloadTypeSet::serialize(JfrCheckpointWriter& writer) {

   307   TypeSetSerialization type_set(true);

   308   if (LeakProfiler::is_running()) {

   309     JfrCheckpointWriter leakp_writer(false, true, Thread::current());

   310     type_set.write(writer, &leakp_writer);

   311     ObjectSampleCheckpoint::install(leakp_writer, true, true);

   312     return;

   313   }

   314   type_set.write(writer, NULL);

   315 };

   317 void TypeSet::serialize(JfrCheckpointWriter& writer) {

   318   TypeSetSerialization type_set(false);

   319   if (LeakProfiler::is_running()) {

   320     JfrCheckpointWriter leakp_writer(false, true, Thread::current());

   321     type_set.write(writer, &leakp_writer);

   322     ObjectSampleCheckpoint::install(leakp_writer, false, true);

   323     return;

   324   }

   325   type_set.write(writer, NULL);

   326 };

   328 void ThreadStateConstant::serialize(JfrCheckpointWriter& writer) {

   329   JfrThreadState::serialize(writer);

   330 }

   332 void JfrThreadConstant::serialize(JfrCheckpointWriter& writer) {

   333   assert(_thread != NULL, "invariant");

   334   assert(_thread == Thread::current(), "invariant");

   335   assert(_thread->is_Java_thread(), "invariant");

   336   assert(!_thread->jfr_thread_local()->has_thread_checkpoint(), "invariant");

   337   ResourceMark rm(_thread);

   338   const oop threadObj = _thread->threadObj();

   339   assert(threadObj != NULL, "invariant");

   340   const u8 java_lang_thread_id = java_lang_Thread::thread_id(threadObj);

   341   const char* const thread_name = _thread->name();

   342   const traceid thread_group_id = JfrThreadGroup::thread_group_id(_thread);

   343   writer.write_count(1);

   344   writer.write_key(_thread->jfr_thread_local()->thread_id());

   345   writer.write(thread_name);

   346   writer.write((traceid)_thread->osthread()->thread_id());

   347   writer.write(thread_name);

   348   writer.write(java_lang_thread_id);

   349   writer.write(thread_group_id);

   350   JfrThreadGroup::serialize(&writer, thread_group_id);

   351 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/jfr/recorder/checkpoint/types/jfrType.cpp@8e875c964f41

src/share/vm/jfr/recorder/checkpoint/types/jfrType.cpp