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
|