< prev index next >

src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeSet.cpp

Print this page
rev 58565 : 8238358: Implementation of JEP 371: Hidden Classes
Reviewed-by: duke
Contributed-by: mandy.chung@oracle.com, lois.foltan@oracle.com, david.holmes@oracle.com, harold.seigel@oracle.com, serguei.spitsyn@oracle.com, alex.buckley@oracle.com, jamsheed.c.m@oracle.com


 120   ModPtr module_entry = pkg->module();
 121   if (module_entry == NULL) {
 122     return 0;
 123   }
 124   if (leakp) {
 125     SET_LEAKP(module_entry);
 126   } else {
 127     SET_TRANSIENT(module_entry);
 128   }
 129   return artifact_id(module_entry);
 130 }
 131 
 132 static traceid method_id(KlassPtr klass, MethodPtr method) {
 133   assert(klass != NULL, "invariant");
 134   assert(method != NULL, "invariant");
 135   return METHOD_ID(klass, method);
 136 }
 137 
 138 static traceid cld_id(CldPtr cld, bool leakp) {
 139   assert(cld != NULL, "invariant");
 140   assert(!cld->is_unsafe_anonymous(), "invariant");
 141   if (leakp) {
 142     SET_LEAKP(cld);
 143   } else {
 144     SET_TRANSIENT(cld);
 145   }
 146   return artifact_id(cld);
 147 }
 148 
 149 template <typename T>
 150 static s4 get_flags(const T* ptr) {
 151   assert(ptr != NULL, "invariant");
 152   return ptr->access_flags().get_flags();
 153 }
 154 
 155 static bool is_unsafe_anonymous(const Klass* klass) {
 156   assert(klass != NULL, "invariant");
 157   assert(!klass->is_objArray_klass(), "invariant");
 158   return klass->is_instance_klass() && InstanceKlass::cast(klass)->is_unsafe_anonymous();
 159 }
 160 
 161 static ClassLoaderData* get_cld(const Klass* klass) {
 162   assert(klass != NULL, "invariant");
 163   if (klass->is_objArray_klass()) {
 164     klass = ObjArrayKlass::cast(klass)->bottom_klass();
 165   }

 166   return is_unsafe_anonymous(klass) ?
 167     InstanceKlass::cast(klass)->unsafe_anonymous_host()->class_loader_data() : klass->class_loader_data();
 168 }
 169 
 170 template <typename T>
 171 static void set_serialized(const T* ptr) {
 172   assert(ptr != NULL, "invariant");
 173   SET_SERIALIZED(ptr);
 174   assert(IS_SERIALIZED(ptr), "invariant");
 175   CLEAR_THIS_EPOCH_CLEARED_BIT(ptr);
 176 }
 177 
 178 /*
 179  * In C++03, functions used as template parameters must have external linkage;
 180  * this restriction was removed in C++11. Change back to "static" and
 181  * rename functions when C++11 becomes available.
 182  *
 183  * The weird naming is an effort to decrease the risk of name clashes.
 184  */
 185 
 186 static int write_klass(JfrCheckpointWriter* writer, KlassPtr klass, bool leakp) {
 187   assert(writer != NULL, "invariant");
 188   assert(_artifacts != NULL, "invariant");
 189   assert(klass != NULL, "invariant");
 190   writer->write(artifact_id(klass));
 191   writer->write(cld_id(get_cld(klass), leakp));

 192   writer->write(mark_symbol(klass, leakp));
 193   writer->write(package_id(klass, leakp));
 194   writer->write(get_flags(klass));

 195   return 1;
 196 }
 197 
 198 int write__klass(JfrCheckpointWriter* writer, const void* k) {
 199   assert(k != NULL, "invariant");
 200   KlassPtr klass = (KlassPtr)k;
 201   set_serialized(klass);
 202   return write_klass(writer, klass, false);
 203 }
 204 
 205 int write__klass__leakp(JfrCheckpointWriter* writer, const void* k) {
 206   assert(k != NULL, "invariant");
 207   KlassPtr klass = (KlassPtr)k;
 208   return write_klass(writer, klass, true);
 209 }
 210 
 211 static bool is_implied(const Klass* klass) {
 212   assert(klass != NULL, "invariant");
 213   return klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass();
 214 }


 529     ClearArtifact<ModPtr> clear;
 530     CompositeModuleWriterWithClear cmwwc(&cmw, &clear);
 531     CompositeModuleCallback callback(&cmwwc);
 532     _subsystem_callback = &callback;
 533     do_modules();
 534   }
 535   _artifacts->tally(mw);
 536 }
 537 
 538 typedef JfrArtifactCallbackHost<ModPtr, ClearArtifact<ModPtr> > ClearModuleCallback;
 539 
 540 static void clear_modules() {
 541   ClearArtifact<ModPtr> clear;
 542   ClearModuleCallback callback(&clear);
 543   _subsystem_callback = &callback;
 544   do_modules();
 545 }
 546 
 547 static int write_classloader(JfrCheckpointWriter* writer, CldPtr cld, bool leakp) {
 548   assert(cld != NULL, "invariant");
 549   assert(!cld->is_unsafe_anonymous(), "invariant");
 550   // class loader type
 551   const Klass* class_loader_klass = cld->class_loader_klass();
 552   if (class_loader_klass == NULL) {
 553     // (primordial) boot class loader
 554     writer->write(artifact_id(cld)); // class loader instance id
 555     writer->write((traceid)0);  // class loader type id (absence of)
 556     writer->write(get_bootstrap_name(leakp)); // maps to synthetic name -> "bootstrap"
 557   } else {
 558     writer->write(artifact_id(cld)); // class loader instance id
 559     writer->write(artifact_id(class_loader_klass)); // class loader type id
 560     writer->write(mark_symbol(cld->name(), leakp)); // class loader instance name
 561   }
 562   return 1;
 563 }
 564 
 565 int write__classloader(JfrCheckpointWriter* writer, const void* c) {
 566   assert(c != NULL, "invariant");
 567   CldPtr cld = (CldPtr)c;
 568   set_serialized(cld);
 569   return write_classloader(writer, cld, false);


 587     assert(klass != NULL, "invariant");
 588     return get_cld(klass);
 589   }
 590 };
 591 
 592 class ModuleCldFieldSelector {
 593 public:
 594   typedef CldPtr TypePtr;
 595   static TypePtr select(KlassPtr klass) {
 596     assert(klass != NULL, "invariant");
 597     ModPtr mod = ModuleFieldSelector::select(klass);
 598     return mod != NULL ? mod->loader_data() : NULL;
 599   }
 600 };
 601 
 602 class CLDCallback : public CLDClosure {
 603  public:
 604   CLDCallback() {}
 605   void do_cld(ClassLoaderData* cld) {
 606     assert(cld != NULL, "invariant");
 607     if (cld->is_unsafe_anonymous()) {
 608       return;
 609     }
 610     do_class_loader_data(cld);
 611   }
 612 };
 613 
 614 static void do_class_loaders() {
 615   CLDCallback cld_cb;
 616   ClassLoaderDataGraph::loaded_cld_do(&cld_cb);
 617 }
 618 
 619 typedef SerializePredicate<CldPtr> CldPredicate;
 620 typedef JfrPredicatedTypeWriterImplHost<CldPtr, CldPredicate, write__classloader> CldWriterImpl;
 621 typedef JfrTypeWriterHost<CldWriterImpl, TYPE_CLASSLOADER> CldWriter;
 622 typedef CompositeFunctor<CldPtr, CldWriter, ClearArtifact<CldPtr> > CldWriterWithClear;
 623 typedef JfrArtifactCallbackHost<CldPtr, CldWriterWithClear> CldCallback;
 624 typedef KlassToFieldEnvelope<KlassCldFieldSelector, CldWriter> KlassCldWriter;
 625 typedef KlassToFieldEnvelope<ModuleCldFieldSelector, CldWriter> ModuleCldWriter;
 626 typedef CompositeFunctor<KlassPtr, KlassCldWriter, ModuleCldWriter> KlassAndModuleCldWriter;
 627 




 120   ModPtr module_entry = pkg->module();
 121   if (module_entry == NULL) {
 122     return 0;
 123   }
 124   if (leakp) {
 125     SET_LEAKP(module_entry);
 126   } else {
 127     SET_TRANSIENT(module_entry);
 128   }
 129   return artifact_id(module_entry);
 130 }
 131 
 132 static traceid method_id(KlassPtr klass, MethodPtr method) {
 133   assert(klass != NULL, "invariant");
 134   assert(method != NULL, "invariant");
 135   return METHOD_ID(klass, method);
 136 }
 137 
 138 static traceid cld_id(CldPtr cld, bool leakp) {
 139   assert(cld != NULL, "invariant");

 140   if (leakp) {
 141     SET_LEAKP(cld);
 142   } else {
 143     SET_TRANSIENT(cld);
 144   }
 145   return artifact_id(cld);
 146 }
 147 
 148 template <typename T>
 149 static s4 get_flags(const T* ptr) {
 150   assert(ptr != NULL, "invariant");
 151   return ptr->access_flags().get_flags();
 152 }
 153 
 154 static bool is_unsafe_anonymous(const Klass* klass) {
 155   assert(klass != NULL, "invariant");
 156   assert(!klass->is_objArray_klass(), "invariant");
 157   return klass->is_instance_klass() && InstanceKlass::cast(klass)->is_unsafe_anonymous();
 158 }
 159 
 160 static ClassLoaderData* get_cld(const Klass* klass) {
 161   assert(klass != NULL, "invariant");
 162   if (klass->is_objArray_klass()) {
 163     klass = ObjArrayKlass::cast(klass)->bottom_klass();
 164   }
 165   if (klass->is_hidden_weak()) return NULL;
 166   return is_unsafe_anonymous(klass) ?
 167     InstanceKlass::cast(klass)->unsafe_anonymous_host()->class_loader_data() : klass->class_loader_data();
 168 }
 169 
 170 template <typename T>
 171 static void set_serialized(const T* ptr) {
 172   assert(ptr != NULL, "invariant");
 173   SET_SERIALIZED(ptr);
 174   assert(IS_SERIALIZED(ptr), "invariant");
 175   CLEAR_THIS_EPOCH_CLEARED_BIT(ptr);
 176 }
 177 
 178 /*
 179  * In C++03, functions used as template parameters must have external linkage;
 180  * this restriction was removed in C++11. Change back to "static" and
 181  * rename functions when C++11 becomes available.
 182  *
 183  * The weird naming is an effort to decrease the risk of name clashes.
 184  */
 185 
 186 static int write_klass(JfrCheckpointWriter* writer, KlassPtr klass, bool leakp) {
 187   assert(writer != NULL, "invariant");
 188   assert(_artifacts != NULL, "invariant");
 189   assert(klass != NULL, "invariant");
 190   writer->write(artifact_id(klass));
 191   ClassLoaderData* cld = get_cld(klass);
 192   writer->write(cld != NULL ? cld_id(cld, leakp) : 0);
 193   writer->write(mark_symbol(klass, leakp));
 194   writer->write(package_id(klass, leakp));
 195   writer->write(get_flags(klass));
 196   writer->write<bool>(klass->is_hidden());
 197   return 1;
 198 }
 199 
 200 int write__klass(JfrCheckpointWriter* writer, const void* k) {
 201   assert(k != NULL, "invariant");
 202   KlassPtr klass = (KlassPtr)k;
 203   set_serialized(klass);
 204   return write_klass(writer, klass, false);
 205 }
 206 
 207 int write__klass__leakp(JfrCheckpointWriter* writer, const void* k) {
 208   assert(k != NULL, "invariant");
 209   KlassPtr klass = (KlassPtr)k;
 210   return write_klass(writer, klass, true);
 211 }
 212 
 213 static bool is_implied(const Klass* klass) {
 214   assert(klass != NULL, "invariant");
 215   return klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass();
 216 }


 531     ClearArtifact<ModPtr> clear;
 532     CompositeModuleWriterWithClear cmwwc(&cmw, &clear);
 533     CompositeModuleCallback callback(&cmwwc);
 534     _subsystem_callback = &callback;
 535     do_modules();
 536   }
 537   _artifacts->tally(mw);
 538 }
 539 
 540 typedef JfrArtifactCallbackHost<ModPtr, ClearArtifact<ModPtr> > ClearModuleCallback;
 541 
 542 static void clear_modules() {
 543   ClearArtifact<ModPtr> clear;
 544   ClearModuleCallback callback(&clear);
 545   _subsystem_callback = &callback;
 546   do_modules();
 547 }
 548 
 549 static int write_classloader(JfrCheckpointWriter* writer, CldPtr cld, bool leakp) {
 550   assert(cld != NULL, "invariant");

 551   // class loader type
 552   const Klass* class_loader_klass = cld->class_loader_klass();
 553   if (class_loader_klass == NULL) {
 554     // (primordial) boot class loader
 555     writer->write(artifact_id(cld)); // class loader instance id
 556     writer->write((traceid)0);  // class loader type id (absence of)
 557     writer->write(get_bootstrap_name(leakp)); // maps to synthetic name -> "bootstrap"
 558   } else {
 559     writer->write(artifact_id(cld)); // class loader instance id
 560     writer->write(artifact_id(class_loader_klass)); // class loader type id
 561     writer->write(mark_symbol(cld->name(), leakp)); // class loader instance name
 562   }
 563   return 1;
 564 }
 565 
 566 int write__classloader(JfrCheckpointWriter* writer, const void* c) {
 567   assert(c != NULL, "invariant");
 568   CldPtr cld = (CldPtr)c;
 569   set_serialized(cld);
 570   return write_classloader(writer, cld, false);


 588     assert(klass != NULL, "invariant");
 589     return get_cld(klass);
 590   }
 591 };
 592 
 593 class ModuleCldFieldSelector {
 594 public:
 595   typedef CldPtr TypePtr;
 596   static TypePtr select(KlassPtr klass) {
 597     assert(klass != NULL, "invariant");
 598     ModPtr mod = ModuleFieldSelector::select(klass);
 599     return mod != NULL ? mod->loader_data() : NULL;
 600   }
 601 };
 602 
 603 class CLDCallback : public CLDClosure {
 604  public:
 605   CLDCallback() {}
 606   void do_cld(ClassLoaderData* cld) {
 607     assert(cld != NULL, "invariant");
 608     if (cld->has_class_mirror_holder()) {
 609       return;
 610     }
 611     do_class_loader_data(cld);
 612   }
 613 };
 614 
 615 static void do_class_loaders() {
 616   CLDCallback cld_cb;
 617   ClassLoaderDataGraph::loaded_cld_do(&cld_cb);
 618 }
 619 
 620 typedef SerializePredicate<CldPtr> CldPredicate;
 621 typedef JfrPredicatedTypeWriterImplHost<CldPtr, CldPredicate, write__classloader> CldWriterImpl;
 622 typedef JfrTypeWriterHost<CldWriterImpl, TYPE_CLASSLOADER> CldWriter;
 623 typedef CompositeFunctor<CldPtr, CldWriter, ClearArtifact<CldPtr> > CldWriterWithClear;
 624 typedef JfrArtifactCallbackHost<CldPtr, CldWriterWithClear> CldCallback;
 625 typedef KlassToFieldEnvelope<KlassCldFieldSelector, CldWriter> KlassCldWriter;
 626 typedef KlassToFieldEnvelope<ModuleCldFieldSelector, CldWriter> ModuleCldWriter;
 627 typedef CompositeFunctor<KlassPtr, KlassCldWriter, ModuleCldWriter> KlassAndModuleCldWriter;
 628 


< prev index next >