80 // helper function to avoid in-line casts
81 template <typename T> static T* load_ptr_acquire(T* volatile *p) {
82 return static_cast<T*>(OrderAccess::load_ptr_acquire(p));
83 }
84
85 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
86
87 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
88 _class_loader(h_class_loader()),
89 _is_anonymous(is_anonymous),
90 // An anonymous class loader data doesn't have anything to keep
91 // it from being unloaded during parsing of the anonymous class.
92 // The null-class-loader should always be kept alive.
93 _keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0),
94 _metaspace(NULL), _unloading(false), _klasses(NULL),
95 _modules(NULL), _packages(NULL),
96 _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
97 _next(NULL), _dependencies(dependencies), _shared_class_loader_id(-1),
98 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
99 Monitor::_safepoint_check_never)) {
100 // empty
101 }
102
103 void ClassLoaderData::init_dependencies(TRAPS) {
104 assert(!Universe::is_fully_initialized(), "should only be called when initializing");
105 assert(is_the_null_class_loader_data(), "should only call this for the null class loader");
106 _dependencies.init(CHECK);
107 }
108
109 void ClassLoaderData::Dependencies::init(TRAPS) {
110 // Create empty dependencies array to add to. CMS requires this to be
111 // an oop so that it can track additions via card marks. We think.
112 _list_head = oopFactory::new_objectArray(2, CHECK);
113 }
114
115 bool ClassLoaderData::claim() {
116 if (_claimed == 1) {
117 return false;
118 }
119
120 return (int) Atomic::cmpxchg(1, &_claimed, 0) == 0;
150 _handles->oops_do(f);
151 }
152 if (klass_closure != NULL) {
153 classes_do(klass_closure);
154 }
155 }
156
157 void ClassLoaderData::Dependencies::oops_do(OopClosure* f) {
158 f->do_oop((oop*)&_list_head);
159 }
160
161 void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
162 // Lock-free access requires load_ptr_acquire
163 for (Klass* k = load_ptr_acquire(&_klasses); k != NULL; k = k->next_link()) {
164 klass_closure->do_klass(k);
165 assert(k != k->next_link(), "no loops!");
166 }
167 }
168
169 void ClassLoaderData::classes_do(void f(Klass * const)) {
170 assert_locked_or_safepoint(_metaspace_lock);
171 for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
172 f(k);
173 }
174 }
175
176 void ClassLoaderData::methods_do(void f(Method*)) {
177 // Lock-free access requires load_ptr_acquire
178 for (Klass* k = load_ptr_acquire(&_klasses); k != NULL; k = k->next_link()) {
179 if (k->is_instance_klass()) {
180 InstanceKlass::cast(k)->methods_do(f);
181 }
182 }
183 }
184
185 void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) {
186 // Lock to avoid classes being modified/added/removed during iteration
187 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
188 for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
189 // Do not filter ArrayKlass oops here...
190 if (k->is_array_klass() || (k->is_instance_klass() && InstanceKlass::cast(k)->is_loaded())) {
191 klass_closure->do_klass(k);
192 }
795 if (cld->keep_alive()) {
796 cld->oops_do(f, klass_closure, must_claim);
797 }
798 }
799 }
800
801 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
802 if (ClassUnloading) {
803 keep_alive_oops_do(f, klass_closure, must_claim);
804 } else {
805 oops_do(f, klass_closure, must_claim);
806 }
807 }
808
809 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
810 for (ClassLoaderData* cld = _head; cl != NULL && cld != NULL; cld = cld->next()) {
811 cl->do_cld(cld);
812 }
813 }
814
815 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
816 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
817 CLDClosure* closure = cld->keep_alive() ? strong : weak;
818 if (closure != NULL) {
819 closure->do_cld(cld);
820 }
821 }
822 }
823
824 void ClassLoaderDataGraph::keep_alive_cld_do(CLDClosure* cl) {
825 roots_cld_do(cl, NULL);
826 }
827
828 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
829 if (ClassUnloading) {
830 keep_alive_cld_do(cl);
831 } else {
832 cld_do(cl);
833 }
834 }
1025 }
1026
1027 void ClassLoaderDataGraph::purge() {
1028 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
1029 ClassLoaderData* list = _unloading;
1030 _unloading = NULL;
1031 ClassLoaderData* next = list;
1032 bool classes_unloaded = false;
1033 while (next != NULL) {
1034 ClassLoaderData* purge_me = next;
1035 next = purge_me->next();
1036 delete purge_me;
1037 classes_unloaded = true;
1038 }
1039 if (classes_unloaded) {
1040 Metaspace::purge();
1041 set_metaspace_oom(false);
1042 }
1043 }
1044
1045 void ClassLoaderDataGraph::post_class_unload_events(void) {
1046 #if INCLUDE_TRACE
1047 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
1048 if (Tracing::enabled()) {
1049 if (Tracing::is_event_enabled(TraceClassUnloadEvent)) {
1050 assert(_unloading != NULL, "need class loader data unload list!");
1051 _class_unload_time = Ticks::now();
1052 classes_unloading_do(&class_unload_event);
1053 }
1054 Tracing::on_unloading_classes();
1055 }
1056 #endif
1057 }
1058
1059 // CDS support
1060
1061 // Global metaspaces for writing information to the shared archive. When
1062 // application CDS is supported, we may need one per metaspace, so this
1063 // sort of looks like it.
1064 Metaspace* ClassLoaderData::_ro_metaspace = NULL;
1065 Metaspace* ClassLoaderData::_rw_metaspace = NULL;
1174 void ClassLoaderData::print_value_on(outputStream* out) const {
1175 if (class_loader() == NULL) {
1176 out->print("NULL class_loader");
1177 } else {
1178 out->print("class loader " INTPTR_FORMAT " ", p2i(this));
1179 class_loader()->print_value_on(out);
1180 }
1181 }
1182
1183 #if INCLUDE_TRACE
1184
1185 Ticks ClassLoaderDataGraph::_class_unload_time;
1186
1187 void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
1188 assert(k != NULL, "invariant");
1189
1190 // post class unload event
1191 EventClassUnload event(UNTIMED);
1192 event.set_endtime(_class_unload_time);
1193 event.set_unloadedClass(k);
1194 oop defining_class_loader = k->class_loader();
1195 event.set_definingClassLoader(defining_class_loader != NULL ?
1196 defining_class_loader->klass() : (Klass*)NULL);
1197 event.commit();
1198 }
1199
1200 #endif // INCLUDE_TRACE
|
80 // helper function to avoid in-line casts
81 template <typename T> static T* load_ptr_acquire(T* volatile *p) {
82 return static_cast<T*>(OrderAccess::load_ptr_acquire(p));
83 }
84
85 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
86
87 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
88 _class_loader(h_class_loader()),
89 _is_anonymous(is_anonymous),
90 // An anonymous class loader data doesn't have anything to keep
91 // it from being unloaded during parsing of the anonymous class.
92 // The null-class-loader should always be kept alive.
93 _keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0),
94 _metaspace(NULL), _unloading(false), _klasses(NULL),
95 _modules(NULL), _packages(NULL),
96 _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
97 _next(NULL), _dependencies(dependencies), _shared_class_loader_id(-1),
98 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
99 Monitor::_safepoint_check_never)) {
100 TRACE_INIT_ID(this);
101 }
102
103 void ClassLoaderData::init_dependencies(TRAPS) {
104 assert(!Universe::is_fully_initialized(), "should only be called when initializing");
105 assert(is_the_null_class_loader_data(), "should only call this for the null class loader");
106 _dependencies.init(CHECK);
107 }
108
109 void ClassLoaderData::Dependencies::init(TRAPS) {
110 // Create empty dependencies array to add to. CMS requires this to be
111 // an oop so that it can track additions via card marks. We think.
112 _list_head = oopFactory::new_objectArray(2, CHECK);
113 }
114
115 bool ClassLoaderData::claim() {
116 if (_claimed == 1) {
117 return false;
118 }
119
120 return (int) Atomic::cmpxchg(1, &_claimed, 0) == 0;
150 _handles->oops_do(f);
151 }
152 if (klass_closure != NULL) {
153 classes_do(klass_closure);
154 }
155 }
156
157 void ClassLoaderData::Dependencies::oops_do(OopClosure* f) {
158 f->do_oop((oop*)&_list_head);
159 }
160
161 void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
162 // Lock-free access requires load_ptr_acquire
163 for (Klass* k = load_ptr_acquire(&_klasses); k != NULL; k = k->next_link()) {
164 klass_closure->do_klass(k);
165 assert(k != k->next_link(), "no loops!");
166 }
167 }
168
169 void ClassLoaderData::classes_do(void f(Klass * const)) {
170 // Lock-free access requires load_ptr_acquire
171 for (Klass* k = load_ptr_acquire(&_klasses); k != NULL; k = k->next_link()) {
172 f(k);
173 assert(k != k->next_link(), "no loops!");
174 }
175 }
176
177 void ClassLoaderData::methods_do(void f(Method*)) {
178 // Lock-free access requires load_ptr_acquire
179 for (Klass* k = load_ptr_acquire(&_klasses); k != NULL; k = k->next_link()) {
180 if (k->is_instance_klass()) {
181 InstanceKlass::cast(k)->methods_do(f);
182 }
183 }
184 }
185
186 void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) {
187 // Lock to avoid classes being modified/added/removed during iteration
188 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
189 for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
190 // Do not filter ArrayKlass oops here...
191 if (k->is_array_klass() || (k->is_instance_klass() && InstanceKlass::cast(k)->is_loaded())) {
192 klass_closure->do_klass(k);
193 }
796 if (cld->keep_alive()) {
797 cld->oops_do(f, klass_closure, must_claim);
798 }
799 }
800 }
801
802 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
803 if (ClassUnloading) {
804 keep_alive_oops_do(f, klass_closure, must_claim);
805 } else {
806 oops_do(f, klass_closure, must_claim);
807 }
808 }
809
810 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
811 for (ClassLoaderData* cld = _head; cl != NULL && cld != NULL; cld = cld->next()) {
812 cl->do_cld(cld);
813 }
814 }
815
816 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
817 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
818 // Only walk the head until any clds not purged from prior unloading
819 // (CMS doesn't purge right away).
820 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
821 assert(cld->is_unloading(), "invariant");
822 cl->do_cld(cld);
823 }
824 }
825
826 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
827 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
828 CLDClosure* closure = cld->keep_alive() ? strong : weak;
829 if (closure != NULL) {
830 closure->do_cld(cld);
831 }
832 }
833 }
834
835 void ClassLoaderDataGraph::keep_alive_cld_do(CLDClosure* cl) {
836 roots_cld_do(cl, NULL);
837 }
838
839 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
840 if (ClassUnloading) {
841 keep_alive_cld_do(cl);
842 } else {
843 cld_do(cl);
844 }
845 }
1036 }
1037
1038 void ClassLoaderDataGraph::purge() {
1039 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
1040 ClassLoaderData* list = _unloading;
1041 _unloading = NULL;
1042 ClassLoaderData* next = list;
1043 bool classes_unloaded = false;
1044 while (next != NULL) {
1045 ClassLoaderData* purge_me = next;
1046 next = purge_me->next();
1047 delete purge_me;
1048 classes_unloaded = true;
1049 }
1050 if (classes_unloaded) {
1051 Metaspace::purge();
1052 set_metaspace_oom(false);
1053 }
1054 }
1055
1056 void ClassLoaderDataGraph::post_class_unload_events() {
1057 #if INCLUDE_TRACE
1058 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
1059 if (Tracing::enabled()) {
1060 if (Tracing::is_event_enabled(TraceClassUnloadEvent)) {
1061 assert(_unloading != NULL, "need class loader data unload list!");
1062 _class_unload_time = Ticks::now();
1063 classes_unloading_do(&class_unload_event);
1064 }
1065 Tracing::on_unloading_classes();
1066 }
1067 #endif
1068 }
1069
1070 // CDS support
1071
1072 // Global metaspaces for writing information to the shared archive. When
1073 // application CDS is supported, we may need one per metaspace, so this
1074 // sort of looks like it.
1075 Metaspace* ClassLoaderData::_ro_metaspace = NULL;
1076 Metaspace* ClassLoaderData::_rw_metaspace = NULL;
1185 void ClassLoaderData::print_value_on(outputStream* out) const {
1186 if (class_loader() == NULL) {
1187 out->print("NULL class_loader");
1188 } else {
1189 out->print("class loader " INTPTR_FORMAT " ", p2i(this));
1190 class_loader()->print_value_on(out);
1191 }
1192 }
1193
1194 #if INCLUDE_TRACE
1195
1196 Ticks ClassLoaderDataGraph::_class_unload_time;
1197
1198 void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
1199 assert(k != NULL, "invariant");
1200
1201 // post class unload event
1202 EventClassUnload event(UNTIMED);
1203 event.set_endtime(_class_unload_time);
1204 event.set_unloadedClass(k);
1205 event.set_definingClassLoader(k->class_loader_data());
1206 event.commit();
1207 }
1208
1209 #endif // INCLUDE_TRACE
|