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

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

    69   return module_entry != NULL && module_entry->is_named() ? TRACE_ID(module_entry) : 0;

   108   if (module_entry != NULL && module_entry->is_named()) {

    70 }

   109     SET_TRANSIENT(module_entry);

    71 

   110     return artifact_id(module_entry);

    72 static traceid package_id(KlassPtr klass) {

   111   }

   112   return 0;

   113 }

   114 

   115 static traceid method_id(KlassPtr klass, MethodPtr method) {

    74   PkgPtr pkg_entry = klass->package();

   117   assert(method != NULL, "invariant");

    75   return pkg_entry == NULL ? 0 : TRACE_ID(pkg_entry);

   118   return METHOD_ID(klass, method);

    80   return cld->is_unsafe_anonymous() ? 0 : TRACE_ID(cld);

   123   if (cld->is_unsafe_anonymous()) {

    81 }

   124     return 0;

    82 

   125   }

    83 static void tag_leakp_klass_artifacts(KlassPtr k, bool current_epoch) {

   126   SET_TRANSIENT(cld);

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

   127   return artifact_id(cld);

    85   PkgPtr pkg = k->package();

   128 }

    86   if (pkg != NULL) {

   129 

    87     tag_leakp_artifact(pkg, current_epoch);

   130 template <typename T>

    88     ModPtr module = pkg->module();

   131 static s4 get_flags(const T* ptr) {

    89     if (module != NULL) {

   132   assert(ptr != NULL, "invariant");

    90       tag_leakp_artifact(module, current_epoch);

   133   return ptr->access_flags().get_flags();

    91     }

   134 }

    92   }

   135 

    93   CldPtr cld = k->class_loader_data();

   136 template <typename T>

    94   assert(cld != NULL, "invariant");

   137 static void set_serialized(const T* ptr) {

    95   if (!cld->is_unsafe_anonymous()) {

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

    96     tag_leakp_artifact(cld, current_epoch);

   139   SET_SERIALIZED(ptr);

    97   }

   140   assert(IS_SERIALIZED(ptr), "invariant");

    98 }

   141 }

    99 

   100 class TagLeakpKlassArtifact {

   101   bool _current_epoch;

   102  public:

   103   TagLeakpKlassArtifact(bool current_epoch) : _current_epoch(current_epoch) {}

   104   bool operator()(KlassPtr klass) {

   105     if (_current_epoch) {

   106       if (LEAKP_USED_THIS_EPOCH(klass)) {

   107         tag_leakp_klass_artifacts(klass, _current_epoch);

   108       }

   109     } else {

   110       if (LEAKP_USED_PREV_EPOCH(klass)) {

   111         tag_leakp_klass_artifacts(klass, _current_epoch);

   112       }

   113     }

   114     return true;

   115   }

   116 };

   126 int write__artifact__klass(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, KlassPtr klass) {

   151 int write__klass(JfrCheckpointWriter* writer, const void* k) {

   128   assert(artifacts != NULL, "invariant");

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

   129   assert(klass != NULL, "invariant");

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

   155   KlassPtr klass = (KlassPtr)k;

   141   const traceid symbol_id = artifacts->mark(klass);

   167   writer->write(artifact_id(klass));

   142   assert(symbol_id > 0, "need to have an address for symbol!");

   143   writer->write(TRACE_ID(klass));

   145   writer->write((traceid)CREATE_SYMBOL_ID(symbol_id));

   169   writer->write(mark_symbol(klass));

   147   writer->write((s4)klass->access_flags().get_flags());

   171   writer->write(get_flags(klass));

   172   set_serialized(klass);

   151 int write__artifact__klass__leakp(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* k) {

   176 static void do_implied(Klass* klass) {

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

   153   KlassPtr klass = (KlassPtr)k;

   154   return write__artifact__klass(writer, artifacts, klass);

   155 }

   156 

   157 int write__artifact__klass__serialize(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* k) {

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

   159   KlassPtr klass = (KlassPtr)k;

   160   int result = write__artifact__klass(writer, artifacts, klass);

   161   if (IS_NOT_SERIALIZED(klass)) {

   162     SET_SERIALIZED(klass);

   163   }

   164   assert(IS_SERIALIZED(klass), "invariant");

   165   return result;

   166 }

   167 

   168 typedef LeakPredicate<KlassPtr> LeakKlassPredicate;

   169 typedef SerializePredicate<KlassPtr> KlassPredicate;

   170 typedef JfrPredicatedArtifactWriterImplHost<KlassPtr, LeakKlassPredicate, write__artifact__klass__leakp> LeakKlassWriterImpl;

   171 typedef JfrArtifactWriterHost<LeakKlassWriterImpl, TYPE_CLASS> LeakKlassWriter;

   172 typedef JfrPredicatedArtifactWriterImplHost<KlassPtr, KlassPredicate, write__artifact__klass__serialize> KlassWriterImpl;

   173 typedef JfrArtifactWriterHost<KlassWriterImpl, TYPE_CLASS> KlassWriter;

   174 

   175 int write__artifact__method(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, MethodPtr method) {

   176   assert(writer != NULL, "invariant");

   177   assert(artifacts != NULL, "invariant");

   178   const traceid method_name_symbol_id = artifacts->mark(method->name());

   179   assert(method_name_symbol_id > 0, "invariant");

   180   const traceid method_sig_symbol_id = artifacts->mark(method->signature());

   181   assert(method_sig_symbol_id > 0, "invariant");

   182   KlassPtr klass = method->method_holder();

   184   assert(METHOD_USED_ANY_EPOCH(klass), "invariant");

   178   if (klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass()) {

   185   writer->write((u8)METHOD_ID(klass, method));

   179     _subsystem_callback->do_artifact(klass);

   186   writer->write((u8)TRACE_ID(klass));

   180   }

   187   writer->write((u8)CREATE_SYMBOL_ID(method_name_symbol_id));

   181 }

   188   writer->write((u8)CREATE_SYMBOL_ID(method_sig_symbol_id));

   182 

   189   writer->write((u2)method->access_flags().get_flags());

   183 static void do_unloaded_klass(Klass* klass) {

   190   writer->write(const_cast<Method*>(method)->is_hidden() ? (u1)1 : (u1)0);

   191   return 1;

   192 }

   193 

   194 int write__artifact__method__leakp(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* m) {

   195   assert(m != NULL, "invariant");

   196   MethodPtr method = (MethodPtr)m;

   197   return write__artifact__method(writer, artifacts, method);

   198 }

   199 

   200 int write__artifact__method__serialize(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* m) {

   201   assert(m != NULL, "invariant");

   202   MethodPtr method = (MethodPtr)m;

   203   int result = write__artifact__method(writer, artifacts, method);

   204   if (METHOD_NOT_SERIALIZED(method)) {

   205     SET_METHOD_SERIALIZED(method);

   206   }

   207   assert(IS_METHOD_SERIALIZED(method), "invariant");

   208   return result;

   209 }

   210 

   211 typedef JfrArtifactWriterImplHost<MethodPtr, write__artifact__method__leakp> LeakpMethodWriterImplTarget;

   212 typedef JfrArtifactWriterHost<LeakpMethodWriterImplTarget, TYPE_METHOD> LeakpMethodWriterImpl;

   213 typedef SerializePredicate<MethodPtr> MethodPredicate;

   214 typedef JfrPredicatedArtifactWriterImplHost<MethodPtr, MethodPredicate, write__artifact__method__serialize> MethodWriterImplTarget;

   215 typedef JfrArtifactWriterHost<MethodWriterImplTarget, TYPE_METHOD> MethodWriterImpl;

   216 

   217 int write__artifact__package(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, PkgPtr pkg) {

   218   assert(writer != NULL, "invariant");

   219   assert(artifacts != NULL, "invariant");

   220   assert(pkg != NULL, "invariant");

   221   Symbol* const pkg_name = pkg->name();

   222   const traceid package_name_symbol_id = pkg_name != NULL ? artifacts->mark(pkg_name) : 0;

   223   assert(package_name_symbol_id > 0, "invariant");

   224   writer->write((traceid)TRACE_ID(pkg));

   225   writer->write((traceid)CREATE_SYMBOL_ID(package_name_symbol_id));

   226   writer->write(module_id(pkg));

   227   writer->write((bool)pkg->is_exported());

   228   return 1;

   229 }

   230 

   231 int write__artifact__package__leakp(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* p) {

   232   assert(p != NULL, "invariant");

   233   PkgPtr pkg = (PkgPtr)p;

   234   return write__artifact__package(writer, artifacts, pkg);

   235 }

   236 

   237 int write__artifact__package__serialize(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* p) {

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

   239   PkgPtr pkg = (PkgPtr)p;

   240   int result = write__artifact__package(writer, artifacts, pkg);

   241   if (IS_NOT_SERIALIZED(pkg)) {

   242     SET_SERIALIZED(pkg);

   243   }

   244   assert(IS_SERIALIZED(pkg), "invariant");

   245   return result;

   246 }

   247 

   248 typedef LeakPredicate<PkgPtr> LeakPackagePredicate;

   249 //int _compare_pkg_ptr_(PkgPtr const& lhs, PkgPtr const& rhs) { return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0; }

   250 //typedef UniquePredicate<PkgPtr, _compare_pkg_ptr_> PackagePredicate;

   251 typedef SerializePredicate<PkgPtr> PackagePredicate;

   252 typedef JfrPredicatedArtifactWriterImplHost<PkgPtr, LeakPackagePredicate, write__artifact__package__leakp> LeakPackageWriterImpl;

   253 typedef JfrPredicatedArtifactWriterImplHost<PkgPtr, PackagePredicate, write__artifact__package__serialize> PackageWriterImpl;

   254 typedef JfrArtifactWriterHost<LeakPackageWriterImpl, TYPE_PACKAGE> LeakPackageWriter;

   255 typedef JfrArtifactWriterHost<PackageWriterImpl, TYPE_PACKAGE> PackageWriter;

   256 

   257 int write__artifact__module(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, ModPtr entry) {

   258   assert(entry != NULL, "invariant");

   259   Symbol* const module_name = entry->name();

   260   const traceid module_name_symbol_id = module_name != NULL ? artifacts->mark(module_name) : 0;

   261   Symbol* const module_version = entry->version();

   262   const traceid module_version_symbol_id = module_version != NULL ? artifacts->mark(module_version) : 0;

   263   Symbol* const module_location = entry->location();

   264   const traceid module_location_symbol_id = module_location != NULL ? artifacts->mark(module_location) : 0;

   265   writer->write((traceid)TRACE_ID(entry));

   266   writer->write(module_name_symbol_id == 0 ? (traceid)0 : (traceid)CREATE_SYMBOL_ID(module_name_symbol_id));

   267   writer->write(module_version_symbol_id == 0 ? (traceid)0 : (traceid)CREATE_SYMBOL_ID(module_version_symbol_id));

   268   writer->write(module_location_symbol_id == 0 ? (traceid)0 : (traceid)CREATE_SYMBOL_ID(module_location_symbol_id));

   269   writer->write(cld_id(entry->loader_data()));

   270   return 1;

   271 }

   272 

   273 int write__artifact__module__leakp(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* m) {

   274   assert(m != NULL, "invariant");

   275   ModPtr entry = (ModPtr)m;

   276   return write__artifact__module(writer, artifacts, entry);

   277 }

   278 

   279 int write__artifact__module__serialize(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* m) {

   280   assert(m != NULL, "invariant");

   281   ModPtr entry = (ModPtr)m;

   282   int result = write__artifact__module(writer, artifacts, entry);

   283   CldPtr cld = entry->loader_data();

   284   assert(cld != NULL, "invariant");

   285   if (IS_NOT_SERIALIZED(cld)) {

   286     if (!cld->is_unsafe_anonymous()) {

   287       SET_USED_PREV_EPOCH(cld);

   288     }

   289   }

   290   if (IS_NOT_SERIALIZED(entry)) {

   291     SET_SERIALIZED(entry);

   292   }

   293   assert(IS_SERIALIZED(entry), "invariant");

   294   return result;

   295 }

   296 

   297 typedef LeakPredicate<ModPtr> LeakModulePredicate;

   298 //int _compare_mod_ptr_(ModPtr const& lhs, ModPtr const& rhs) { return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0; }

   299 //typedef UniquePredicate<ModPtr, _compare_mod_ptr_> ModulePredicate;

   300 typedef SerializePredicate<ModPtr> ModulePredicate;

   301 typedef JfrPredicatedArtifactWriterImplHost<ModPtr, LeakModulePredicate, write__artifact__module__leakp> LeakModuleWriterImpl;

   302 typedef JfrPredicatedArtifactWriterImplHost<ModPtr, ModulePredicate, write__artifact__module__serialize> ModuleWriterImpl;

   303 typedef JfrArtifactWriterHost<LeakModuleWriterImpl, TYPE_MODULE> LeakModuleWriter;

   304 typedef JfrArtifactWriterHost<ModuleWriterImpl, TYPE_MODULE> ModuleWriter;

   305 

   306 int write__artifact__classloader(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, CldPtr cld) {

   307   assert(cld != NULL, "invariant");

   308   assert(!cld->is_unsafe_anonymous(), "invariant");

   309   const traceid cld_id = TRACE_ID(cld);

   310   // class loader type

   311   const Klass* class_loader_klass = cld->class_loader_klass();

   312   if (class_loader_klass == NULL) {

   313     // (primordial) boot class loader

   314     writer->write(cld_id); // class loader instance id

   315     writer->write((traceid)0);  // class loader type id (absence of)

   316     writer->write((traceid)CREATE_SYMBOL_ID(1)); // 1 maps to synthetic name -> "bootstrap"

   317   } else {

   318     Symbol* symbol_name = cld->name();

   319     const traceid symbol_name_id = symbol_name != NULL ? artifacts->mark(symbol_name) : 0;

   320     writer->write(cld_id); // class loader instance id

   321     writer->write(TRACE_ID(class_loader_klass)); // class loader type id

   322     writer->write(symbol_name_id == 0 ? (traceid)0 :

   323       (traceid)CREATE_SYMBOL_ID(symbol_name_id)); // class loader instance name

   324   }

   325   return 1;

   326 }

   327 

   328 int write__artifact__classloader__leakp(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* c) {

   329   assert(c != NULL, "invariant");

   330   CldPtr cld = (CldPtr)c;

   331   int result = write__artifact__classloader(writer, artifacts, cld);

   332   if (IS_NOT_LEAKP_SERIALIZED(cld)) {

   333     SET_LEAKP_SERIALIZED(cld);

   334   }

   335   assert(IS_LEAKP_SERIALIZED(cld), "invariant");

   336   return result;

   337 }

   338 

   339 int write__artifact__classloader__serialize(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* c) {

   340   assert(c != NULL, "invariant");

   341   CldPtr cld = (CldPtr)c;

   342   int result = write__artifact__classloader(writer, artifacts, cld);

   343   if (IS_NOT_SERIALIZED(cld)) {

   344     SET_SERIALIZED(cld);

   345   }

   346   assert(IS_SERIALIZED(cld), "invariant");

   347   return result;

   348 }

   349 

   350 typedef LeakSerializePredicate<CldPtr> LeakCldPredicate;

   351 //int _compare_cld_ptr_(CldPtr const& lhs, CldPtr const& rhs) { return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0; }

   352 //typedef UniquePredicate<CldPtr, _compare_cld_ptr_> CldPredicate;

   353 typedef SerializePredicate<CldPtr> CldPredicate;

   354 typedef JfrPredicatedArtifactWriterImplHost<CldPtr, LeakCldPredicate, write__artifact__classloader__leakp> LeakCldWriterImpl;

   355 typedef JfrPredicatedArtifactWriterImplHost<CldPtr, CldPredicate, write__artifact__classloader__serialize> CldWriterImpl;

   356 typedef JfrArtifactWriterHost<LeakCldWriterImpl, TYPE_CLASSLOADER> LeakCldWriter;

   357 typedef JfrArtifactWriterHost<CldWriterImpl, TYPE_CLASSLOADER> CldWriter;

   358 

   359 typedef const JfrSymbolId::SymbolEntry* SymbolEntryPtr;

   360 

   361 static int write__artifact__symbol__entry__(JfrCheckpointWriter* writer, SymbolEntryPtr entry) {

   362   assert(writer != NULL, "invariant");

   363   assert(entry != NULL, "invariant");

   364   ResourceMark rm;

   365   writer->write(CREATE_SYMBOL_ID(entry->id()));

   366   writer->write(entry->value()->as_C_string());

   367   return 1;

   368 }

   369 

   370 int write__artifact__symbol__entry(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* e) {

   371   assert(e != NULL, "invariant");

   372   return write__artifact__symbol__entry__(writer, (SymbolEntryPtr)e);

   373 }

   374 

   375 typedef JfrArtifactWriterImplHost<SymbolEntryPtr, write__artifact__symbol__entry> SymbolEntryWriterImpl;

   376 typedef JfrArtifactWriterHost<SymbolEntryWriterImpl, TYPE_SYMBOL> SymbolEntryWriter;

   377 

   378 typedef const JfrSymbolId::CStringEntry* CStringEntryPtr;

   379 

   380 static int write__artifact__cstring__entry__(JfrCheckpointWriter* writer, CStringEntryPtr entry) {

   381   assert(writer != NULL, "invariant");

   382   assert(entry != NULL, "invariant");

   383   writer->write(CREATE_SYMBOL_ID(entry->id()));

   384   writer->write(entry->value());

   385   return 1;

   386 }

   387 

   388 int write__artifact__cstring__entry(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* e) {

   389   assert(e != NULL, "invariant");

   390   return write__artifact__cstring__entry__(writer, (CStringEntryPtr)e);

   391 }

   392 

   393 typedef JfrArtifactWriterImplHost<CStringEntryPtr, write__artifact__cstring__entry> CStringEntryWriterImpl;

   394 typedef JfrArtifactWriterHost<CStringEntryWriterImpl, TYPE_SYMBOL> CStringEntryWriter;

   395 

   396 int write__artifact__klass__symbol(JfrCheckpointWriter* writer, JfrArtifactSet* artifacts, const void* k) {

   397   assert(writer != NULL, "invariant");

   398   assert(artifacts != NULL, "invaiant");

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

   400   const InstanceKlass* const ik = (const InstanceKlass*)k;

   401   if (ik->is_unsafe_anonymous()) {

   402     CStringEntryPtr entry =

   403       artifacts->map_cstring(JfrSymbolId::unsafe_anonymous_klass_name_hash_code(ik));

   404     assert(entry != NULL, "invariant");

   405     return write__artifact__cstring__entry__(writer, entry);

   406   }

   407 

   408   SymbolEntryPtr entry = artifacts->map_symbol(JfrSymbolId::regular_klass_name_hash_code(ik));

   409   return write__artifact__symbol__entry__(writer, entry);

   410 }

   411 

   412 int _compare_traceid_(const traceid& lhs, const traceid& rhs) {

   413   return lhs > rhs ? 1 : (lhs < rhs) ? -1 : 0;

   414 }

   415 

   416 template <template <typename> class Predicate>

   417 class KlassSymbolWriterImpl {

   418  private:

   419   JfrCheckpointWriter* _writer;

   420   JfrArtifactSet* _artifacts;

   421   Predicate<KlassPtr> _predicate;

   422   MethodUsedPredicate<true> _method_used_predicate;

   423   MethodFlagPredicate _method_flag_predicate;

   424   UniquePredicate<traceid, _compare_traceid_> _unique_predicate;

   425 

   426   int klass_symbols(KlassPtr klass);

   427   int package_symbols(PkgPtr pkg);

   428   int module_symbols(ModPtr module);

   429   int class_loader_symbols(CldPtr cld);

   430   int method_symbols(KlassPtr klass);

   431 

   432  public:

   433   typedef KlassPtr Type;

   434   KlassSymbolWriterImpl(JfrCheckpointWriter* writer,

   435                         JfrArtifactSet* artifacts,

   436                         bool current_epoch) : _writer(writer),

   437                                              _artifacts(artifacts),

   438                                              _predicate(current_epoch),

   439                                              _method_used_predicate(current_epoch),

   440                                              _method_flag_predicate(current_epoch),

   441                                              _unique_predicate(current_epoch) {}

   442 

   443   int operator()(KlassPtr klass) {

   444     assert(klass != NULL, "invariant");

   445     int count = 0;

   446     if (_predicate(klass)) {

   447       count += klass_symbols(klass);

   448       PkgPtr pkg = klass->package();

   449       if (pkg != NULL) {

   450         count += package_symbols(pkg);

   451         ModPtr module = pkg->module();

   452         if (module != NULL && module->is_named()) {

   453           count += module_symbols(module);

   454         }

   455       }

   456       CldPtr cld = klass->class_loader_data();

   457       assert(cld != NULL, "invariant");

   458       if (!cld->is_unsafe_anonymous()) {

   459         count += class_loader_symbols(cld);

   460       }

   461       if (_method_used_predicate(klass)) {

   462         count += method_symbols(klass);

   463       }

   464     }

   465     return count;

   466   }

   467 };

   468 

   469 template <template <typename> class Predicate>

   470 int KlassSymbolWriterImpl<Predicate>::klass_symbols(KlassPtr klass) {

   471   assert(klass != NULL, "invariant");

   472   assert(_predicate(klass), "invariant");

   473   const InstanceKlass* const ik = (const InstanceKlass*)klass;

   474   if (ik->is_unsafe_anonymous()) {

   475     CStringEntryPtr entry =

   476       this->_artifacts->map_cstring(JfrSymbolId::unsafe_anonymous_klass_name_hash_code(ik));

   477     assert(entry != NULL, "invariant");

   478     return _unique_predicate(entry->id()) ? write__artifact__cstring__entry__(this->_writer, entry) : 0;

   479   }

   480   SymbolEntryPtr entry = this->_artifacts->map_symbol(ik->name());

   481   assert(entry != NULL, "invariant");

   482   return _unique_predicate(entry->id()) ? write__artifact__symbol__entry__(this->_writer, entry) : 0;

   483 }

   484 

   485 template <template <typename> class Predicate>

   486 int KlassSymbolWriterImpl<Predicate>::package_symbols(PkgPtr pkg) {

   487   assert(pkg != NULL, "invariant");

   488   SymbolPtr pkg_name = pkg->name();

   489   assert(pkg_name != NULL, "invariant");

   490   SymbolEntryPtr package_symbol = this->_artifacts->map_symbol(pkg_name);

   491   assert(package_symbol != NULL, "invariant");

   492   return _unique_predicate(package_symbol->id()) ? write__artifact__symbol__entry__(this->_writer, package_symbol) : 0;

   493 }

   494 

   495 template <template <typename> class Predicate>

   496 int KlassSymbolWriterImpl<Predicate>::module_symbols(ModPtr module) {

   497   assert(module != NULL, "invariant");

   498   assert(module->is_named(), "invariant");

   499   int count = 0;

   500   SymbolPtr sym = module->name();

   501   SymbolEntryPtr entry = NULL;

   502   if (sym != NULL) {

   503     entry = this->_artifacts->map_symbol(sym);

   504     assert(entry != NULL, "invariant");

   505     if (_unique_predicate(entry->id())) {

   506       count += write__artifact__symbol__entry__(this->_writer, entry);

   507     }

   508   }

   509   sym = module->version();

   510   if (sym != NULL) {

   511     entry = this->_artifacts->map_symbol(sym);

   512     assert(entry != NULL, "invariant");

   513     if (_unique_predicate(entry->id())) {

   514       count += write__artifact__symbol__entry__(this->_writer, entry);

   515     }

   516   }

   517   sym = module->location();

   518   if (sym != NULL) {

   519     entry = this->_artifacts->map_symbol(sym);

   520     assert(entry != NULL, "invariant");

   521     if (_unique_predicate(entry->id())) {

   522       count += write__artifact__symbol__entry__(this->_writer, entry);

   523     }

   524   }

   525   return count;

   526 }

   527 

   528 template <template <typename> class Predicate>

   529 int KlassSymbolWriterImpl<Predicate>::class_loader_symbols(CldPtr cld) {

   530   assert(cld != NULL, "invariant");

   531   assert(!cld->is_unsafe_anonymous(), "invariant");

   532   int count = 0;

   533   // class loader type

   534   const Klass* class_loader_klass = cld->class_loader_klass();

   535   if (class_loader_klass == NULL) {

   536     // (primordial) boot class loader

   537     CStringEntryPtr entry = this->_artifacts->map_cstring(0);

   538     assert(entry != NULL, "invariant");

   539     assert(strncmp(entry->literal(),

   540       BOOTSTRAP_LOADER_NAME,

   541       BOOTSTRAP_LOADER_NAME_LEN) == 0, "invariant");

   542     if (_unique_predicate(entry->id())) {

   543       count += write__artifact__cstring__entry__(this->_writer, entry);

   544     }

   545   } else {

   546     const Symbol* class_loader_name = cld->name();

   547     if (class_loader_name != NULL) {

   548       SymbolEntryPtr entry = this->_artifacts->map_symbol(class_loader_name);

   549       assert(entry != NULL, "invariant");

   550       if (_unique_predicate(entry->id())) {

   551         count += write__artifact__symbol__entry__(this->_writer, entry);

   552       }

   553     }

   554   }

   555   return count;

   556 }

   557 

   558 template <template <typename> class Predicate>

   559 int KlassSymbolWriterImpl<Predicate>::method_symbols(KlassPtr klass) {

   560   assert(_predicate(klass), "invariant");

   561   assert(_method_used_predicate(klass), "invariant");

   562   assert(METHOD_AND_CLASS_USED_ANY_EPOCH(klass), "invariant");

   563   int count = 0;

   564   const InstanceKlass* const ik = InstanceKlass::cast(klass);

   565   const int len = ik->methods()->length();

   566   for (int i = 0; i < len; ++i) {

   567     MethodPtr method = ik->methods()->at(i);

   568     if (_method_flag_predicate(method)) {

   569       SymbolEntryPtr entry = this->_artifacts->map_symbol(method->name());

   570       assert(entry != NULL, "invariant");

   571       if (_unique_predicate(entry->id())) {

   572         count += write__artifact__symbol__entry__(this->_writer, entry);

   573       }

   574       entry = this->_artifacts->map_symbol(method->signature());

   575       assert(entry != NULL, "invariant");

   576       if (_unique_predicate(entry->id())) {

   577         count += write__artifact__symbol__entry__(this->_writer, entry);

   578       }

   579     }

   580   }

   581   return count;

   582 }

   583 

   584 typedef KlassSymbolWriterImpl<LeakPredicate> LeakKlassSymbolWriterImpl;

   585 typedef JfrArtifactWriterHost<LeakKlassSymbolWriterImpl, TYPE_SYMBOL> LeakKlassSymbolWriter;

   586 

   587 class ClearKlassAndMethods {

   588  private:

   589   ClearArtifact<KlassPtr> _clear_klass_tag_bits;

   590   ClearArtifact<MethodPtr> _clear_method_flag;

   591   MethodUsedPredicate<false> _method_used_predicate;

   592 

   593  public:

   594   ClearKlassAndMethods(bool current_epoch) : _method_used_predicate(current_epoch) {}

   595   bool operator()(KlassPtr klass) {

   596     if (_method_used_predicate(klass)) {

   597       const InstanceKlass* ik = InstanceKlass::cast(klass);

   598       const int len = ik->methods()->length();

   599       for (int i = 0; i < len; ++i) {

   600         MethodPtr method = ik->methods()->at(i);

   601         _clear_method_flag(method);

   602       }

   603     }

   604     _clear_klass_tag_bits(klass);

   605     return true;

   606   }

   607 };

   608 

   609 typedef CompositeFunctor<KlassPtr,

   610                          TagLeakpKlassArtifact,

   611                          LeakKlassWriter> LeakpKlassArtifactTagging;

   612 

   613 typedef CompositeFunctor<KlassPtr,

   614                          LeakpKlassArtifactTagging,

   615                          KlassWriter> CompositeKlassWriter;

   616 

   617 typedef CompositeFunctor<KlassPtr,

   618                          CompositeKlassWriter,

   619                          KlassArtifactRegistrator> CompositeKlassWriterRegistration;

   620 

   621 typedef CompositeFunctor<KlassPtr,

   622                          KlassWriter,

   623                          KlassArtifactRegistrator> KlassWriterRegistration;

   624 

   625 typedef JfrArtifactCallbackHost<KlassPtr, KlassWriterRegistration> KlassCallback;

   626 typedef JfrArtifactCallbackHost<KlassPtr, CompositeKlassWriterRegistration> CompositeKlassCallback;

   627 

   628 /*

   629  * Composite operation

   630  *

   631  * TagLeakpKlassArtifact ->

   632  *   LeakpPredicate ->

   633  *     LeakpKlassWriter ->

   634  *       KlassPredicate ->

   635  *         KlassWriter ->

   636  *           KlassWriterRegistration

   637  */

   638 void JfrTypeSet::write_klass_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   639   assert(!_artifacts->has_klass_entries(), "invariant");

   640   KlassArtifactRegistrator reg(_artifacts);

   641   KlassWriter kw(writer, _artifacts, current_epoch());

   642   KlassWriterRegistration kwr(&kw, &reg);

   643   if (leakp_writer == NULL) {

   644     KlassCallback callback(&kwr);

   645     _subsystem_callback = &callback;

   646     do_klasses();

   647     _artifacts->tally(kw);

   648     return;

   649   }

   650   TagLeakpKlassArtifact tagging(current_epoch());

   651   LeakKlassWriter lkw(leakp_writer, _artifacts, current_epoch());

   652   LeakpKlassArtifactTagging lpkat(&tagging, &lkw);

   653   CompositeKlassWriter ckw(&lpkat, &kw);

   654   CompositeKlassWriterRegistration ckwr(&ckw, &reg);

   655   CompositeKlassCallback callback(&ckwr);

   656   _subsystem_callback = &callback;

   657   do_klasses();

   658 }

   659 

   660 typedef CompositeFunctor<PkgPtr,

   661                          PackageWriter,

   662                          ClearArtifact<PkgPtr> > PackageWriterWithClear;

   663 

   664 typedef CompositeFunctor<PkgPtr,

   665                          PackageWriter,

   666                          UnTagArtifact<PkgPtr> > PackageWriterWithUnTag;

   667 typedef CompositeFunctor<PkgPtr,

   668                          LeakPackageWriter,

   669                          PackageWriter> CompositePackageWriter;

   670 

   671 typedef CompositeFunctor<PkgPtr,

   672                          CompositePackageWriter,

   673                          ClearArtifact<PkgPtr> > CompositePackageWriterWithClear;

   674 typedef CompositeFunctor<PkgPtr,

   675                          CompositePackageWriter,

   676                          UnTagArtifact<PkgPtr> > CompositePackageWriterWithUnTag;

   677 

   678 class PackageFieldSelector {

   679  public:

   680   typedef PkgPtr TypePtr;

   681   static TypePtr select(KlassPtr klass) {

   682     assert(klass != NULL, "invariant");

   683     return ((InstanceKlass*)klass)->package();

   684   }

   685 };

   686 

   687 typedef KlassToFieldEnvelope<PackageFieldSelector,

   688                              PackageWriterWithClear> KlassPackageWriterWithClear;

   689 

   690 typedef KlassToFieldEnvelope<PackageFieldSelector,

   691                              PackageWriterWithUnTag> KlassPackageWriterWithUnTag;

   692 typedef KlassToFieldEnvelope<PackageFieldSelector, PackageWriter> KlassPackageWriter;

   693 typedef KlassToFieldEnvelope<PackageFieldSelector, CompositePackageWriter> KlassCompositePackageWriter;

   694 typedef KlassToFieldEnvelope<PackageFieldSelector,

   695                              CompositePackageWriterWithClear> KlassCompositePackageWriterWithClear;

   696 

   697 typedef KlassToFieldEnvelope<PackageFieldSelector,

   698                              CompositePackageWriterWithUnTag> KlassCompositePackageWriterWithUnTag;

   699 typedef JfrArtifactCallbackHost<PkgPtr, PackageWriterWithClear> PackageCallback;

   700 typedef JfrArtifactCallbackHost<PkgPtr, CompositePackageWriterWithClear> CompositePackageCallback;

   701 

   702 static void write_package_constants_current_epoch(JfrArtifactSet* artifacts, JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   703   assert(artifacts != NULL, "invariant");

   704   assert(artifacts->has_klass_entries(), "invariant");

   705   PackageWriter pw(writer, artifacts, true);

   706   if (leakp_writer == NULL) {

   707     KlassPackageWriter kpw(&pw);

   708     artifacts->iterate_klasses(kpw);

   709     artifacts->tally(pw);

   710   } else {

   711     LeakPackageWriter lpw(leakp_writer, artifacts, true);

   712     CompositePackageWriter cpw(&lpw, &pw);

   713     KlassCompositePackageWriter kcpw(&cpw);

   714     artifacts->iterate_klasses(kcpw);

   715   }

   716 }

   717 

   718 /*

   719  * Composite operation

   720  *

   721  * LeakpPackageWriter ->

   722  *   PackageWriter ->

   723  *     ClearArtifact<PackageEntry>

   724  *

   725  */

   726 void JfrTypeSet::write_package_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   727   assert(_artifacts->has_klass_entries(), "invariant");

   728   if (current_epoch()) {

   729     write_package_constants_current_epoch(_artifacts, writer, leakp_writer);

   730     return;

   731   }

   732   assert(is_rotating(), "invariant");

   733   PackageWriter pw(writer, _artifacts, false);

   734   ClearArtifact<PkgPtr> clear;

   735   UnTagArtifact<PkgPtr> untag;

   736   if (leakp_writer == NULL) {

   737     PackageWriterWithUnTag kpw(&pw, &untag);

   738     KlassPackageWriterWithUnTag kpwwut(&kpw);

   739     _artifacts->iterate_klasses(kpwwut);

   740     PackageWriterWithClear pwwc(&pw, &clear);

   741     PackageCallback callback(&pwwc);

   742     _subsystem_callback = &callback;

   743     do_packages();

   744     return;

   745   }

   746   LeakPackageWriter lpw(leakp_writer, _artifacts, false);

   747   CompositePackageWriter cpw(&lpw, &pw);

   748   CompositePackageWriterWithUnTag cpwwut(&cpw, &untag);

   749   KlassCompositePackageWriterWithUnTag kcpw(&cpwwut);

   750   _artifacts->iterate_klasses(kcpw);

   751   CompositePackageWriterWithClear cpwwc(&cpw, &clear);

   752   CompositePackageCallback callback(&cpwwc);

   753   _subsystem_callback = &callback;

   754   do_packages();

   755 }

   756 

   757 typedef CompositeFunctor<ModPtr,

   758                          ModuleWriter,

   759                          ClearArtifact<ModPtr> > ModuleWriterWithClear;

   760 

   761 typedef CompositeFunctor<ModPtr,

   762                          ModuleWriter,

   763                          UnTagArtifact<ModPtr> > ModuleWriterWithUnTag;

   764 typedef CompositeFunctor<ModPtr,

   765                          LeakModuleWriter,

   766                          ModuleWriter> CompositeModuleWriter;

   767 

   768 typedef CompositeFunctor<ModPtr,

   769                          CompositeModuleWriter,

   770                          ClearArtifact<ModPtr> > CompositeModuleWriterWithClear;

   771 typedef CompositeFunctor<ModPtr,

   772                          CompositeModuleWriter,

   773                          UnTagArtifact<ModPtr> > CompositeModuleWriterWithUnTag;

   774 

   775 typedef JfrArtifactCallbackHost<ModPtr, ModuleWriterWithClear> ModuleCallback;

   776 typedef JfrArtifactCallbackHost<ModPtr, CompositeModuleWriterWithClear> CompositeModuleCallback;

   777 

   778 class ModuleFieldSelector {

   779  public:

   780   typedef ModPtr TypePtr;

   781   static TypePtr select(KlassPtr klass) {

   782     assert(klass != NULL, "invariant");

   783     PkgPtr pkg = klass->package();

   784     return pkg != NULL ? pkg->module() : NULL;

   785   }

   786 };

   787 

   788 typedef KlassToFieldEnvelope<ModuleFieldSelector,

   789                              ModuleWriterWithClear> KlassModuleWriterWithClear;

   790 

   791 typedef KlassToFieldEnvelope<ModuleFieldSelector,

   792                              ModuleWriterWithUnTag> KlassModuleWriterWithUnTag;

   793 typedef KlassToFieldEnvelope<ModuleFieldSelector, ModuleWriter> KlassModuleWriter;

   794 typedef KlassToFieldEnvelope<ModuleFieldSelector,  CompositeModuleWriter> KlassCompositeModuleWriter;

   795 typedef KlassToFieldEnvelope<ModuleFieldSelector,

   796                              CompositeModuleWriterWithClear> KlassCompositeModuleWriterWithClear;

   797 

   798 typedef KlassToFieldEnvelope<ModuleFieldSelector,

   799                              CompositeModuleWriterWithUnTag> KlassCompositeModuleWriterWithUnTag;

   800 

   801 static void write_module_constants_current_epoch(JfrArtifactSet* artifacts, JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   802   assert(artifacts != NULL, "invariant");

   803   assert(artifacts->has_klass_entries(), "invariant");

   804   ModuleWriter mw(writer, artifacts, true);

   805   if (leakp_writer == NULL) {

   806     KlassModuleWriter kmw(&mw);

   807     artifacts->iterate_klasses(kmw);

   808     artifacts->tally(mw);

   809   } else {

   810     LeakModuleWriter lmw(leakp_writer, artifacts, true);

   811     CompositeModuleWriter cmw(&lmw, &mw);

   812     KlassCompositeModuleWriter kcmw(&cmw);

   813     artifacts->iterate_klasses(kcmw);

   814   }

   815 }

   816 

   817 /*

   818  * Composite operation

   819  *

   820  * LeakpModuleWriter ->

   821  *   ModuleWriter ->

   822  *     ClearArtifact<ModuleEntry>

   823  */

   824 void JfrTypeSet::write_module_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   825   assert(_artifacts->has_klass_entries(), "invariant");

   826   if (current_epoch()) {

   827     write_module_constants_current_epoch(_artifacts, writer, leakp_writer);

   828     return;

   829   }

   830   assert(is_rotating(), "invariant");

   831   ClearArtifact<ModPtr> clear;

   832   UnTagArtifact<ModPtr> untag;

   833   ModuleWriter mw(writer, _artifacts, false);

   834   if (leakp_writer == NULL) {

   835     ModuleWriterWithUnTag kpw(&mw, &untag);

   836     KlassModuleWriterWithUnTag kmwwut(&kpw);

   837     _artifacts->iterate_klasses(kmwwut);

   838     ModuleWriterWithClear mwwc(&mw, &clear);

   839     ModuleCallback callback(&mwwc);

   840     _subsystem_callback = &callback;

   841     do_modules();

   842     return;

   843   }

   844   LeakModuleWriter lmw(leakp_writer, _artifacts, false);

   845   CompositeModuleWriter cmw(&lmw, &mw);

   846   CompositeModuleWriterWithUnTag cmwwut(&cmw, &untag);

   847   KlassCompositeModuleWriterWithUnTag kcmw(&cmwwut);

   848   _artifacts->iterate_klasses(kcmw);

   849   CompositeModuleWriterWithClear cmwwc(&cmw, &clear);

   850   CompositeModuleCallback callback(&cmwwc);

   851   _subsystem_callback = &callback;

   852   do_modules();

   853 }

   854 

   855 typedef CompositeFunctor<CldPtr, CldWriter, ClearArtifact<CldPtr> > CldWriterWithClear;

   856 typedef CompositeFunctor<CldPtr, CldWriter, UnTagArtifact<CldPtr> > CldWriterWithUnTag;

   857 typedef CompositeFunctor<CldPtr, LeakCldWriter, CldWriter> CompositeCldWriter;

   858 typedef CompositeFunctor<CldPtr, CompositeCldWriter, ClearArtifact<CldPtr> > CompositeCldWriterWithClear;

   859 typedef CompositeFunctor<CldPtr, CompositeCldWriter, UnTagArtifact<CldPtr> > CompositeCldWriterWithUnTag;

   860 typedef JfrArtifactCallbackHost<CldPtr, CldWriterWithClear> CldCallback;

   861 typedef JfrArtifactCallbackHost<CldPtr, CompositeCldWriterWithClear> CompositeCldCallback;

   862 

   863 class CldFieldSelector {

   864  public:

   865   typedef CldPtr TypePtr;

   866   static TypePtr select(KlassPtr klass) {

   867     assert(klass != NULL, "invariant");

   868     CldPtr cld = klass->class_loader_data();

   869     return cld->is_unsafe_anonymous() ? NULL : cld;

   870   }

   871 };

   872 

   873 typedef KlassToFieldEnvelope<CldFieldSelector, CldWriter> KlassCldWriter;

   874 typedef KlassToFieldEnvelope<CldFieldSelector, CldWriterWithClear> KlassCldWriterWithClear;

   875 typedef KlassToFieldEnvelope<CldFieldSelector, CldWriterWithUnTag> KlassCldWriterWithUnTag;

   876 typedef KlassToFieldEnvelope<CldFieldSelector, CompositeCldWriter> KlassCompositeCldWriter;

   877 typedef KlassToFieldEnvelope<CldFieldSelector, CompositeCldWriterWithClear> KlassCompositeCldWriterWithClear;

   878 typedef KlassToFieldEnvelope<CldFieldSelector, CompositeCldWriterWithUnTag> KlassCompositeCldWriterWithUnTag;

   879 

   880 static void write_class_loader_constants_current_epoch(JfrArtifactSet* artifacts, JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   881   assert(artifacts != NULL, "invariant");

   882   assert(artifacts->has_klass_entries(), "invariant");

   883   CldWriter cldw(writer, artifacts, true);

   884   if (leakp_writer == NULL) {

   885     KlassCldWriter kcw(&cldw);

   886     artifacts->iterate_klasses(kcw);

   887     artifacts->tally(cldw);

   888   } else {

   889     LeakCldWriter lcldw(leakp_writer, artifacts, true);

   890     CompositeCldWriter ccldw(&lcldw, &cldw);

   891     KlassCompositeCldWriter kccldw(&ccldw);

   892     artifacts->iterate_klasses(kccldw);

   893   }

   894 }

   895 

   896 /*

   897  * Composite operation

   898  *

   899  * LeakpClassLoaderWriter ->

   900  *   ClassLoaderWriter ->

   901  *     ClearArtifact<ClassLoaderData>

   902  */

   903 void JfrTypeSet::write_class_loader_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   904   assert(_artifacts->has_klass_entries(), "invariant");

   905   if (current_epoch()) {

   906     write_class_loader_constants_current_epoch(_artifacts, writer, leakp_writer);

   907     return;

   908   }

   909   assert(is_rotating(), "invariant");

   910   ClearArtifact<CldPtr> clear;

   911   UnTagArtifact<CldPtr> untag;

   912   CldWriter cldw(writer, _artifacts, false);

   913   if (leakp_writer == NULL) {

   914     CldWriterWithUnTag cldwut(&cldw, &untag);

   915     KlassCldWriterWithUnTag kcldwut(&cldwut);

   916     _artifacts->iterate_klasses(kcldwut);

   917     CldWriterWithClear cldwwc(&cldw, &clear);

   918     CldCallback callback(&cldwwc);

   919     _subsystem_callback = &callback;

   920     do_class_loaders();

   921     return;

   922   }

   923   LeakCldWriter lcldw(leakp_writer, _artifacts, false);

   924   CompositeCldWriter ccldw(&lcldw, &cldw);

   925   CompositeCldWriterWithUnTag cldwwut(&ccldw, &untag);

   926   KlassCompositeCldWriterWithUnTag kccldw(&cldwwut);

   927   _artifacts->iterate_klasses(kccldw);

   928   CompositeCldWriterWithClear ccldwwc(&ccldw, &clear);

   929   CompositeCldCallback callback(&ccldwwc);

   930   _subsystem_callback = &callback;

   931   do_class_loaders();

   932 }

   933 

   934 template <bool predicate_bool, typename MethodFunctor>

   935 class MethodIteratorHost {

   936  private:

   937   MethodFunctor _method_functor;

   938   MethodUsedPredicate<predicate_bool> _method_used_predicate;

   939   MethodFlagPredicate _method_flag_predicate;

   940 

   941  public:

   942   MethodIteratorHost(JfrCheckpointWriter* writer,

   943                      JfrArtifactSet* artifacts,

   944                      bool current_epoch,

   945                      bool skip_header = false) :

   946     _method_functor(writer, artifacts, current_epoch, skip_header),

   947     _method_used_predicate(current_epoch),

   948     _method_flag_predicate(current_epoch) {}

   949 

   950   bool operator()(KlassPtr klass) {

   951     if (_method_used_predicate(klass)) {

   952       assert(METHOD_AND_CLASS_USED_ANY_EPOCH(klass), "invariant");

   953       const InstanceKlass* ik = InstanceKlass::cast(klass);

   954       const int len = ik->methods()->length();

   955       for (int i = 0; i < len; ++i) {

   956         MethodPtr method = ik->methods()->at(i);

   957         if (_method_flag_predicate(method)) {

   958           _method_functor(method);

   959         }

   960       }

   961     }

   962     return true;

   963   }

   964 

   965   int count() const { return _method_functor.count(); }

   966   void add(int count) { _method_functor.add(count); }

   967 };

   968 

   969 typedef MethodIteratorHost<true /*leakp */,  LeakpMethodWriterImpl> LeakMethodWriter;

   970 typedef MethodIteratorHost<false, MethodWriterImpl> MethodWriter;

   971 typedef CompositeFunctor<KlassPtr, LeakMethodWriter, MethodWriter> CompositeMethodWriter;

   972 

   973 /*

   974  * Composite operation

   975  *

   976  * LeakpMethodWriter ->

   977  *   MethodWriter

   978  */

   979 void JfrTypeSet::write_method_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

   980   assert(_artifacts->has_klass_entries(), "invariant");

   981   MethodWriter mw(writer, _artifacts, is_not_rotating());

   982   if (leakp_writer == NULL) {

   983     _artifacts->iterate_klasses(mw);

   984     _artifacts->tally(mw);

   985     return;

   986   }

   987   LeakMethodWriter lpmw(leakp_writer, _artifacts, is_not_rotating());

   988   CompositeMethodWriter cmw(&lpmw, &mw);

   989   _artifacts->iterate_klasses(cmw);

   990 }

   991 

   992 static void write_symbols_leakp(JfrCheckpointWriter* leakp_writer, JfrArtifactSet* artifacts, bool current_epoch) {

   993   assert(leakp_writer != NULL, "invariant");

   994   assert(artifacts != NULL, "invariant");

   995   LeakKlassSymbolWriter lpksw(leakp_writer, artifacts, current_epoch);

   996   artifacts->iterate_klasses(lpksw);

   997 }

   998 

   999 static void write_symbols(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer, JfrArtifactSet* artifacts, bool current_epoch) {

  1000   assert(writer != NULL, "invariant");

  1001   assert(artifacts != NULL, "invariant");

  1002   if (leakp_writer != NULL) {

  1003     write_symbols_leakp(leakp_writer, artifacts, current_epoch);

  1004   }

  1005   // iterate all registered symbols

  1006   SymbolEntryWriter symbol_writer(writer, artifacts, current_epoch);

  1007   artifacts->iterate_symbols(symbol_writer);

  1008   CStringEntryWriter cstring_writer(writer, artifacts, current_epoch, true); // skip header

  1009   artifacts->iterate_cstrings(cstring_writer);

  1010   symbol_writer.add(cstring_writer.count());

  1011   artifacts->tally(symbol_writer);

  1012 }

  1013 

  1014 bool JfrTypeSet::_class_unload = false;

  1015 bool JfrTypeSet::_flushpoint = false;

  1016 JfrArtifactSet* JfrTypeSet::_artifacts = NULL;

  1017 JfrArtifactClosure* JfrTypeSet::_subsystem_callback = NULL;

  1018 

  1019 bool JfrTypeSet::is_rotating() {

  1020   return !(_class_unload || _flushpoint);

  1021 }

  1022 

  1023 bool JfrTypeSet::is_not_rotating() {

  1024   return !is_rotating();

  1025 }

  1026 

  1027 bool JfrTypeSet::current_epoch() {

  1028   return is_not_rotating();

  1029 }

  1030 

  1031 void JfrTypeSet::write_symbol_constants(JfrCheckpointWriter* writer, JfrCheckpointWriter* leakp_writer) {

  1032   assert(writer != NULL, "invariant");

  1033   assert(_artifacts->has_klass_entries(), "invariant");

  1034   write_symbols(writer, leakp_writer, _artifacts, _class_unload);

  1035 }

  1036 

  1037 void JfrTypeSet::do_unloaded_klass(Klass* klass) {

  1043   if (USED_THIS_EPOCH(klass)) { // includes leakp subset

   189   if (USED_THIS_EPOCH(klass)) {

   190     ObjectSampleCheckpoint::on_klass_unload(klass);

  1047   if (klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass()) {

   194   do_implied(klass);

  1048     SET_LEAKP_USED_THIS_EPOCH(klass); // tag leakp "safe byte" for subset inclusion

   195 }

  1049     _subsystem_callback->do_artifact(klass);

   196 

  1050   }

   197 static void do_klass(Klass* klass) {

  1051 }

  1052 

  1053 void JfrTypeSet::do_klass(Klass* klass) {

  1062     if (USED_PREV_EPOCH(klass)) { // includes leakp subset

   206     if (USED_PREV_EPOCH(klass)) {

  1067   if (klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass()) {

   211   do_implied(klass);

  1068     if (_flushpoint) {

   212 }

  1069       SET_LEAKP_USED_THIS_EPOCH(klass);

   213 

  1070     } else {

   214 static void do_klasses() {

  1071       SET_LEAKP_USED_PREV_EPOCH(klass); // tag leakp "safe byte" for subset inclusion

  1072     }

  1073     _subsystem_callback->do_artifact(klass);

  1074   }

  1075 }

  1076 

  1077 void JfrTypeSet::do_klasses() {

  1085 template <typename T>

   222 typedef SerializePredicate<KlassPtr> KlassPredicate;

  1086 static void do_current_epoch_artifact(JfrArtifactClosure* callback, T* value) {

   223 typedef JfrPredicatedTypeWriterImplHost<KlassPtr, KlassPredicate, write__klass> KlassWriterImpl;

  1087   assert(callback != NULL, "invariant");

   224 typedef JfrTypeWriterHost<KlassWriterImpl, TYPE_CLASS> KlassWriter;

  1088   assert(value != NULL, "invariant");

   225 typedef CompositeFunctor<KlassPtr, KlassWriter, KlassArtifactRegistrator> KlassWriterRegistration;

  1089   if (ANY_USED_THIS_EPOCH(value)) { // includes leakp subset

   226 typedef JfrArtifactCallbackHost<KlassPtr, KlassWriterRegistration> KlassCallback;

  1090     callback->do_artifact(value);

   227 

  1091   }

   228 static bool write_klasses() {

   229   assert(!_artifacts->has_klass_entries(), "invariant");

   230   assert(_writer != NULL, "invariant");

   231   KlassArtifactRegistrator reg(_artifacts);

   232   KlassWriter kw(_writer, _class_unload);

   233   KlassWriterRegistration kwr(&kw, &reg);

   234   KlassCallback callback(&kwr);

   235   _subsystem_callback = &callback;

   236   do_klasses();

   237   if (is_complete()) {

   238     return false;

   239   }

   240   _artifacts->tally(kw);