40 #include "runtime/interfaceSupport.inline.hpp"

    36 #include "jfr/recorder/checkpoint/jfrCheckpointWriter.hpp"

    41 #include "runtime/mutexLocker.hpp"

    37 #include "jfr/recorder/checkpoint/types/traceid/jfrTraceId.inline.hpp"

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

    38 #include "jfr/recorder/service/jfrOptionSet.hpp"

    43 

    39 #include "jfr/recorder/stacktrace/jfrStackTraceRepository.hpp"

    44 template <typename SampleProcessor>

    40 #include "jfr/utilities/jfrTypes.hpp"

    45 static void do_samples(ObjectSample* sample, const ObjectSample* const end, SampleProcessor& processor) {

    41 #include "runtime/safepoint.hpp"

    42 #include "runtime/thread.hpp"

    43 #include "utilities/growableArray.hpp"

    44 

    45 static bool predicate(GrowableArray<traceid>* set, traceid id) {

    46   assert(set != NULL, "invariant");

    47   bool found = false;

    48   set->find_sorted<traceid, compare_traceid>(id, found);

    49   return found;

    50 }

    51 

    52 static bool mutable_predicate(GrowableArray<traceid>* set, traceid id) {

    53   assert(set != NULL, "invariant");

    54   bool found = false;

    55   const int location = set->find_sorted<traceid, compare_traceid>(id, found);

    56   if (!found) {

    57     set->insert_before(location, id);

    58   }

    59   return found;

    60 }

    61 

    62 static bool add(GrowableArray<traceid>* set, traceid id) {

    63   assert(set != NULL, "invariant");

    64   return mutable_predicate(set, id);

    65 }

    66 

    67 const int initial_array_size = 256;

    68 

    69 template <typename T>

    70 static GrowableArray<T>* c_heap_allocate_array(int size = initial_array_size) {

    71   return new (ResourceObj::C_HEAP, mtTracing) GrowableArray<T>(size, true, mtTracing);

    72 }

    73 

    74 template <typename T>

    75 static GrowableArray<T>* resource_allocate_array(int size = initial_array_size) {

    76   return new GrowableArray<T>(size);

    77 }

    78 

    79 static void sort_array(GrowableArray<traceid>* ar) {

    80   assert(ar != NULL, "invariant");

    81   ar->sort(sort_traceid);

    82 }

    83 

    84 static GrowableArray<traceid>* unloaded_thread_id_set = NULL;

    85 

    86 class ThreadIdExclusiveAccess : public StackObj {

    87  private:

    88   static Semaphore _mutex_semaphore;

    89  public:

    90   ThreadIdExclusiveAccess() { _mutex_semaphore.wait(); }

    91   ~ThreadIdExclusiveAccess() { _mutex_semaphore.signal(); }

    92 };

    93 

    94 Semaphore ThreadIdExclusiveAccess::_mutex_semaphore(1);

    95 

    96 static void add_to_unloaded_thread_set(traceid tid) {

    97   ThreadIdExclusiveAccess lock;

    98   if (unloaded_thread_id_set == NULL) {

    99     unloaded_thread_id_set = c_heap_allocate_array<traceid>();

   100   }

   101   add(unloaded_thread_id_set, tid);

   102 }

   103 

   104 static bool has_thread_exited(traceid tid) {

   105   assert(tid != 0, "invariant");

   106   return unloaded_thread_id_set != NULL && predicate(unloaded_thread_id_set, tid);

   107 }

   108 

   109 static GrowableArray<traceid>* unloaded_set = NULL;

   110 

   111 static void sort_unloaded_set() {

   112   if (unloaded_set != NULL) {

   113     sort_array(unloaded_set);

   114   }

   115 }

   116 

   117 static void add_to_unloaded_set(traceid klass_id) {

   118   if (unloaded_set == NULL) {

   119     unloaded_set = c_heap_allocate_array<traceid>();

   120   }

   121   unloaded_set->append(klass_id);

   122 }

   123 

   124 void ObjectSampleCheckpoint::on_klass_unload(const Klass* k) {

   125   assert(k != NULL, "invariant");

   126   add_to_unloaded_set(TRACE_ID(k));

   127 }

   128 

   129 static bool is_klass_unloaded(traceid klass_id) {

   130   return unloaded_set != NULL && predicate(unloaded_set, klass_id);

   131 }

   132 

   133 static GrowableArray<traceid>* id_set = NULL;

   134 static GrowableArray<traceid>* stack_trace_id_set = NULL;

   135 

   136 static bool is_processed(traceid id) {

   137   assert(id != 0, "invariant");

   138   assert(id_set != NULL, "invariant");

   139   return mutable_predicate(id_set, id);

   140 }

   141 

   142 static bool is_processed_or_unloaded(traceid klass_id) {

   143   assert(klass_id != 0, "invariant");

   144   return is_processed(klass_id) || is_klass_unloaded(klass_id);

   145 }

   146 

   147 static bool should_process(traceid klass_id) {

   148   return klass_id != 0 && !is_processed_or_unloaded(klass_id);

   149 }

   150 

   151 static bool is_stack_trace_processed(traceid stack_trace_id) {

   152   assert(stack_trace_id != 0, "invariant");

   153   assert(stack_trace_id_set != NULL, "invariant");

   154   return mutable_predicate(stack_trace_id_set, stack_trace_id);

   155 }

   156 

   157 template <typename Processor>

   158 static void do_samples(ObjectSample* sample, const ObjectSample* const end, Processor& processor) {

    77 class CheckpointInstall {

   482 static void register_serializers() {

    78  private:

   483   static bool is_registered = false;

    79   const JfrCheckpointBlobHandle& _cp;

   484   if (!is_registered) {

    80  public:

   485     JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTSYSTEM, true, new RootSystemType());

    81   CheckpointInstall(const JfrCheckpointBlobHandle& cp) : _cp(cp) {}

   486     JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTTYPE, true, new RootType());

    82   void sample_do(ObjectSample* sample) {

   487     is_registered = true;

    83     assert(sample != NULL, "invariant");

   488   }

    84     if (!sample->is_dead()) {

   489 }

    85       sample->set_klass_checkpoint(_cp);

   490 

    86     }

   491 static void reset_blob_write_state(const ObjectSample* sample) {

    87   }

   492   assert(sample != NULL, "invariant");

    88 };

   493   if (sample->has_thread_checkpoint()) {

   494     sample->thread_checkpoint()->reset_write_state();

   495   }

   496   if (sample->has_klass_checkpoint()) {

   497     sample->klass_checkpoint()->reset_write_state();

   498   }

   499 }

   500 

   501 static void write_thread_blob(const ObjectSample* sample, JfrCheckpointWriter& writer) {

   502   if (sample->has_thread_checkpoint() && has_thread_exited(sample->thread_id())) {

   503     sample->thread_checkpoint()->exclusive_write(writer);

   504   }

   505 }

   506 

   507 static void write_klass_blob(const ObjectSample* sample, JfrCheckpointWriter& writer) {

   508   if (sample->has_klass_checkpoint()) {

   509     sample->klass_checkpoint()->exclusive_write(writer);

   510   }

   511 }

   512 

   513 static void write_blobs(const ObjectSample* sample, JfrCheckpointWriter& writer) {

   514   assert(sample != NULL, "invariant");

   515   write_thread_blob(sample, writer);

   516   write_klass_blob(sample, writer);

   517 }

    95   CheckpointWrite(JfrCheckpointWriter& writer, jlong last_sweep) : _writer(writer), _last_sweep(last_sweep) {}

   525   CheckpointWrite(const ObjectSampler* sampler, JfrCheckpointWriter& writer, jlong last_sweep) :

   526     _sampler(sampler), _writer(writer), _last_sweep(last_sweep) {}

    99       if (sample->has_thread_checkpoint()) {

   530       write_blobs(sample, _writer);

   100         const JfrCheckpointBlobHandle& thread_cp = sample->thread_checkpoint();

   101         thread_cp->exclusive_write(_writer);

   102       }

   103       if (sample->has_klass_checkpoint()) {

   104         const JfrCheckpointBlobHandle& klass_cp = sample->klass_checkpoint();

   105         klass_cp->exclusive_write(_writer);

   106       }

   115   CheckpointStateReset(jlong last_sweep) : _last_sweep(last_sweep) {}

   540   CheckpointStateReset(const ObjectSampler* sampler, jlong last_sweep) : _sampler(sampler), _last_sweep(last_sweep) {}

   119       if (sample->has_thread_checkpoint()) {

   544       reset_blob_write_state(sample);

   120         const JfrCheckpointBlobHandle& thread_cp = sample->thread_checkpoint();

   545     }

   121         thread_cp->reset_write_state();

   546   }

   122       }

   547 };

   123       if (sample->has_klass_checkpoint()) {

   548 

   124         const JfrCheckpointBlobHandle& klass_cp = sample->klass_checkpoint();

   549 static void reset_write_state_for_blobs(const ObjectSampler* sampler, jlong last_sweep) {

   125         klass_cp->reset_write_state();

   550   CheckpointStateReset state_reset(sampler, last_sweep);

   126       }

   551   iterate_samples(state_reset, true, false);

   127     }

   552 }

   128   }

   553 

   129 };

   554 static void write_sample_blobs(const ObjectSampler* sampler, jlong last_sweep, Thread* thread) {

   555   JfrCheckpointWriter writer(thread, false);

   556   CheckpointWrite checkpoint_write(sampler, writer, last_sweep);

   557   iterate_samples(checkpoint_write, true, false);

   558   reset_write_state_for_blobs(sampler, last_sweep);

   559 }

   137   StackTraceWrite(JfrStackTraceRepository& stack_trace_repo, JfrCheckpointWriter& writer) :

   568   StackTraceWrite(JfrStackTraceRepository& stack_trace_repo, JfrCheckpointWriter& writer, jlong last_sweep) :

   138     _stack_trace_repo(stack_trace_repo), _writer(writer), _count(0) {

   569     _stack_trace_repo(stack_trace_repo), _writer(writer), _last_sweep(last_sweep), _count(0) {}

   139     JfrStacktrace_lock->lock_without_safepoint_check();

   570   void sample_do(ObjectSample* sample) {

   140   }

   571     ObjectSampleCheckpoint::tag(sample);

   141   ~StackTraceWrite() {

   572     if (stack_trace_precondition(sample) && sample->is_alive_and_older_than(_last_sweep)) {

   142     assert(JfrStacktrace_lock->owned_by_self(), "invariant");

   573       assert(sample->stack_trace_id() == sample->stack_trace()->id(), "invariant");

   143     JfrStacktrace_lock->unlock();

   574       if (ObjectSampleCheckpoint::tag(sample->stack_trace(), &_writer)) {

   144   }

   145 

   146   void sample_do(ObjectSample* sample) {

   147     assert(sample != NULL, "invariant");

   148     if (!sample->is_dead()) {

   149       if (sample->has_stack_trace()) {

   150         JfrTraceId::use(sample->klass(), true);

   151         _stack_trace_repo.write(_writer, sample->stack_trace_id(), sample->stack_trace_hash());

   162 class SampleMark {

   584 static void write_and_tag_stack_traces(const ObjectSampler* sampler, JfrStackTraceRepository& repo, jlong last_sweep, Thread* thread) {

   163  private:

   585   assert(sampler != NULL, "invariant");

   164   ObjectSampleMarker& _marker;

   586   allocate_traceid_working_sets();

   165   jlong _last_sweep;

   587   install_new_stack_traces(repo);

   166   int _count;

   588   JfrCheckpointWriter writer(thread);

   167  public:

   589   const JfrCheckpointContext ctx = writer.context();

   168   SampleMark(ObjectSampleMarker& marker, jlong last_sweep) : _marker(marker),

   590   writer.write_type(TYPE_STACKTRACE);

   169                                                              _last_sweep(last_sweep),

   591   const jlong count_offset = writer.reserve(sizeof(u4));

   170                                                              _count(0) {}

   592   StackTraceWrite sw(repo, writer, last_sweep);

   171   void sample_do(ObjectSample* sample) {

   593   do_samples(sampler->last(), NULL, sw);

   172     assert(sample != NULL, "invariant");

   594   if (sw.count() == 0) {

   173     if (sample->is_alive_and_older_than(_last_sweep)) {

   595     writer.set_context(ctx);

   174       _marker.mark(sample->object());

   175       ++_count;

   176     }

   177   }

   178 

   179   int count() const {

   180     return _count;

   181   }

   182 };

   183 

   184 void ObjectSampleCheckpoint::install(JfrCheckpointWriter& writer, bool class_unload, bool resume) {

   185   assert(class_unload ? SafepointSynchronize::is_at_safepoint() : LeakProfiler::is_suspended(), "invariant");

   186 

   187   if (!writer.has_data()) {

   188     if (!class_unload) {

   189       LeakProfiler::resume();

   190     }

   191     assert(LeakProfiler::is_running(), "invariant");

   194 

   598   writer.write_count((u4)sw.count(), count_offset);

   195   assert(writer.has_data(), "invariant");

   599 }

   196   const JfrCheckpointBlobHandle h_cp = writer.checkpoint_blob();

   600 

   197 

   601 void ObjectSampleCheckpoint::write(const ObjectSampler* sampler, EdgeStore* edge_store, bool emit_all, Thread* thread) {

   198   const ObjectSampler* const object_sampler = LeakProfiler::object_sampler();

   602   assert(sampler != NULL, "invariant");

   199   assert(object_sampler != NULL, "invariant");

   200 

   201   ObjectSample* const last = const_cast<ObjectSample*>(object_sampler->last());

   202   const ObjectSample* const last_resolved = object_sampler->last_resolved();

   203   CheckpointInstall install(h_cp);

   204 

   205   if (class_unload) {

   206     if (last != NULL) {

   207       // all samples need the class unload information

   208       do_samples(last, NULL, install);

   209     }

   210     assert(LeakProfiler::is_running(), "invariant");

   211     return;

   212   }

   213 

   214   // only new samples since last resolved checkpoint

   215   if (last != last_resolved) {

   216     do_samples(last, last_resolved, install);

   217     if (resume) {

   218       const_cast<ObjectSampler*>(object_sampler)->set_last_resolved(last);

   219     }

   220   }

   221   assert(LeakProfiler::is_suspended(), "invariant");

   222   if (resume) {

   223     LeakProfiler::resume();

   224     assert(LeakProfiler::is_running(), "invariant");

   225   }

   226 }

   227 

   228 void ObjectSampleCheckpoint::write(const EdgeStore* edge_store, bool emit_all, Thread* thread) {

   231   static bool types_registered = false;

   605   register_serializers();

   232   if (!types_registered) {

   606   // sample set is predicated on time of last sweep

   233     JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTSYSTEM, true, new RootSystemType());

   607   const jlong last_sweep = emit_all ? max_jlong : sampler->last_sweep().value();

   234     JfrSerializer::register_serializer(TYPE_OLDOBJECTROOTTYPE, true, new RootType());

   608   write_and_tag_stack_traces(sampler, JfrStackTraceRepository::instance(), last_sweep, thread);

   235     types_registered = true;

   609   write_sample_blobs(sampler, last_sweep, thread);

   236   }

   610   // write reference chains

   237   const ObjectSampler* const object_sampler = LeakProfiler::object_sampler();

   238   assert(object_sampler != NULL, "invariant");

   239   const jlong last_sweep = emit_all ? max_jlong : object_sampler->last_sweep().value();

   240   ObjectSample* const last = const_cast<ObjectSample*>(object_sampler->last());

   241   {

   242     JfrCheckpointWriter writer(false, false, thread);

   243     CheckpointWrite checkpoint_write(writer, last_sweep);

   244     do_samples(last, NULL, checkpoint_write);

   245   }

   246   CheckpointStateReset state_reset(last_sweep);

   247   do_samples(last, NULL, state_reset);

   249     // java object and chain representations

   612     JfrCheckpointWriter writer(thread);

   250     JfrCheckpointWriter writer(false, true, thread);

   252     edge_store->iterate_edges(osw);

   614     edge_store->iterate(osw);

   253   }

   615   }

   254 }

   616 }

   255 

   256 WriteObjectSampleStacktrace::WriteObjectSampleStacktrace(JfrStackTraceRepository& repo) :

   257   _stack_trace_repo(repo) {

   258 }

   259 

   260 bool WriteObjectSampleStacktrace::process() {

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

   262   if (!LeakProfiler::is_running()) {

   263     return true;

   264   }

   265   // Suspend the LeakProfiler subsystem

   266   // to ensure stable samples even

   267   // after we return from the safepoint.

   268   LeakProfiler::suspend();

   269   assert(!LeakProfiler::is_running(), "invariant");

   270   assert(LeakProfiler::is_suspended(), "invariant");

   271 

   272   const ObjectSampler* object_sampler = LeakProfiler::object_sampler();

   273   assert(object_sampler != NULL, "invariant");

   274   assert(LeakProfiler::is_suspended(), "invariant");

   275 

   276   ObjectSample* const last = const_cast<ObjectSample*>(object_sampler->last());

   277   const ObjectSample* const last_resolved = object_sampler->last_resolved();

   278   if (last == last_resolved) {

   279     assert(LeakProfiler::is_suspended(), "invariant");

   280     return true;

   281   }

   282 

   283   JfrCheckpointWriter writer(false, true, Thread::current());

   284   const JfrCheckpointContext ctx = writer.context();

   285 

   286   writer.write_type(TYPE_STACKTRACE);

   287   const jlong count_offset = writer.reserve(sizeof(u4));

   288 

   289   int count = 0;

   290   {

   291     StackTraceWrite stack_trace_write(_stack_trace_repo, writer); // JfrStacktrace_lock

   292     do_samples(last, last_resolved, stack_trace_write);

   293     count = stack_trace_write.count();

   294   }

   295   if (count == 0) {

   296     writer.set_context(ctx);

   297     assert(LeakProfiler::is_suspended(), "invariant");

   298     return true;

   299   }

   300   assert(count > 0, "invariant");

   301   writer.write_count((u4)count, count_offset);

   302   JfrStackTraceRepository::write_metadata(writer);

   303 

   304   ObjectSampleCheckpoint::install(writer, false, false);

   305   assert(LeakProfiler::is_suspended(), "invariant");

   306   return true;

   307 }

   308 

   309 int ObjectSampleCheckpoint::mark(ObjectSampleMarker& marker, bool emit_all) {

   310   const ObjectSampler* object_sampler = LeakProfiler::object_sampler();

   311   assert(object_sampler != NULL, "invariant");

   312   ObjectSample* const last = const_cast<ObjectSample*>(object_sampler->last());

   313   if (last == NULL) {

   314     return 0;

   315   }

   316   const jlong last_sweep = emit_all ? max_jlong : object_sampler->last_sweep().value();

   317   SampleMark mark(marker, last_sweep);

   318   do_samples(last, NULL, mark);

   319   return mark.count();

   320 }