jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlass.cpp

equal deleted inserted replaced

-:04b19236aa98
+:59f3c8a69541
 }
 #endif
 #if INCLUDE_JVMTI
-// RedefineClasses() support for previous versions:
+// RedefineClasses() support for previous versions
-int InstanceKlass::_previous_version_count = 0;
+// Globally, there is at least one previous version of a class to walk
-// Purge previous versions before adding new previous versions of the class.
+// during class unloading, which is saved because old methods in the class
-void InstanceKlass::purge_previous_versions(InstanceKlass* ik) {
+// are still running.   Otherwise the previous version list is cleaned up.
-if (ik->previous_versions() != NULL) {
+bool InstanceKlass::_has_previous_versions = false;
-// This klass has previous versions so see what we can cleanup
-// while it is safe to do so.
+// Returns true if there are previous versions of a class for class
+// unloading only. Also resets the flag to false. purge_previous_version
-int deleted_count = 0;    // leave debugging breadcrumbs
+// will set the flag to true if there are any left, i.e., if there's any
-int live_count = 0;
+// work to do for next time. This is to avoid the expensive code cache
-ClassLoaderData* loader_data = ik->class_loader_data();
+// walk in CLDG::do_unloading().
-assert(loader_data != NULL, "should never be null");
+bool InstanceKlass::has_previous_versions_and_reset() {
+bool ret = _has_previous_versions;
-ResourceMark rm;
+log_trace(redefine, class, iklass, purge)("Class unloading: has_previous_versions = %s",
-log_trace(redefine, class, iklass, purge)("%s: previous versions", ik->external_name());
+ret ? "true" : "false");
+_has_previous_versions = false;
-// previous versions are linked together through the InstanceKlass
+return ret;
-InstanceKlass* pv_node = ik->previous_versions();
+}
-InstanceKlass* last = ik;
-int version = 0;
+// Purge previous versions before adding new previous versions of the class and
+// during class unloading.
-// check the previous versions list
+void InstanceKlass::purge_previous_version_list() {
-for (; pv_node != NULL; ) {
+assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
+assert(has_been_redefined(), "Should only be called for main class");
-ConstantPool* pvcp = pv_node->constants();
-assert(pvcp != NULL, "cp ref was unexpectedly cleared");
+// Quick exit.
+if (previous_versions() == NULL) {
-if (!pvcp->on_stack()) {
+return;
-// If the constant pool isn't on stack, none of the methods
+}
-// are executing.  Unlink this previous_version.
-// The previous version InstanceKlass is on the ClassLoaderData deallocate list
+// This klass has previous versions so see what we can cleanup
-// so will be deallocated during the next phase of class unloading.
+// while it is safe to do so.
-log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is dead", p2i(pv_node));
-// For debugging purposes.
+int deleted_count = 0;    // leave debugging breadcrumbs
-pv_node->set_is_scratch_class();
+int live_count = 0;
-pv_node->class_loader_data()->add_to_deallocate_list(pv_node);
+ClassLoaderData* loader_data = class_loader_data();
-pv_node = pv_node->previous_versions();
+assert(loader_data != NULL, "should never be null");
-last->link_previous_versions(pv_node);
-deleted_count++;
+ResourceMark rm;
-version++;
+log_trace(redefine, class, iklass, purge)("%s: previous versions", external_name());
-continue;
-} else {
+// previous versions are linked together through the InstanceKlass
-log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is alive", p2i(pv_node));
+InstanceKlass* pv_node = previous_versions();
-assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
+InstanceKlass* last = this;
-guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
+int version = 0;
-live_count++;
-}
+// check the previous versions list
+for (; pv_node != NULL; ) {
-// At least one method is live in this previous version.
-// Reset dead EMCP methods not to get breakpoints.
+ConstantPool* pvcp = pv_node->constants();
-// All methods are deallocated when all of the methods for this class are no
+assert(pvcp != NULL, "cp ref was unexpectedly cleared");
-// longer running.
-Array<Method*>* method_refs = pv_node->methods();
+if (!pvcp->on_stack()) {
-if (method_refs != NULL) {
+// If the constant pool isn't on stack, none of the methods
-log_trace(redefine, class, iklass, purge)("previous methods length=%d", method_refs->length());
+// are executing.  Unlink this previous_version.
-for (int j = 0; j < method_refs->length(); j++) {
+// The previous version InstanceKlass is on the ClassLoaderData deallocate list
-Method* method = method_refs->at(j);
+// so will be deallocated during the next phase of class unloading.
+log_trace(redefine, class, iklass, purge)
-if (!method->on_stack()) {
+("previous version " INTPTR_FORMAT " is dead.", p2i(pv_node));
-// no breakpoints for non-running methods
+// For debugging purposes.
-if (method->is_running_emcp()) {
+pv_node->set_is_scratch_class();
-method->set_running_emcp(false);
+// Unlink from previous version list.
-}
+assert(pv_node->class_loader_data() == loader_data, "wrong loader_data");
-} else {
+InstanceKlass* next = pv_node->previous_versions();
-assert (method->is_obsolete() || method->is_running_emcp(),
+pv_node->link_previous_versions(NULL);   // point next to NULL
-"emcp method cannot run after emcp bit is cleared");
+last->link_previous_versions(next);
-log_trace(redefine, class, iklass, purge)
+// Add to the deallocate list after unlinking
-("purge: %s(%s): prev method @%d in version @%d is alive",
+loader_data->add_to_deallocate_list(pv_node);
-method->name()->as_C_string(), method->signature()->as_C_string(), j, version);
+pv_node = next;
+deleted_count++;
+version++;
+continue;
+} else {
+log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is alive", p2i(pv_node));
+assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
+guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
+live_count++;
+// found a previous version for next time we do class unloading
+_has_previous_versions = true;
+}
+// At least one method is live in this previous version.
+// Reset dead EMCP methods not to get breakpoints.
+// All methods are deallocated when all of the methods for this class are no
+// longer running.
+Array<Method*>* method_refs = pv_node->methods();
+if (method_refs != NULL) {
+log_trace(redefine, class, iklass, purge)("previous methods length=%d", method_refs->length());
+for (int j = 0; j < method_refs->length(); j++) {
+Method* method = method_refs->at(j);
+if (!method->on_stack()) {
+// no breakpoints for non-running methods
+if (method->is_running_emcp()) {
+method->set_running_emcp(false);
 }
+} else {
+assert (method->is_obsolete() || method->is_running_emcp(),
+"emcp method cannot run after emcp bit is cleared");
+log_trace(redefine, class, iklass, purge)
+("purge: %s(%s): prev method @%d in version @%d is alive",
+method->name()->as_C_string(), method->signature()->as_C_string(), j, version);
 }
 }
-// next previous version
+}
-last = pv_node;
+// next previous version
-pv_node = pv_node->previous_versions();
+last = pv_node;
-version++;
+pv_node = pv_node->previous_versions();
-}
+version++;
-log_trace(redefine, class, iklass, purge)
+}
-("previous version stats: live=%d, deleted=%d",
+log_trace(redefine, class, iklass, purge)
-live_count, deleted_count);
+("previous version stats: live=%d, deleted=%d", live_count, deleted_count);
-}
 }
 void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods,
 int emcp_method_count) {
 int obsolete_method_count = old_methods->length() - emcp_method_count;
 ResourceMark rm;
 log_trace(redefine, class, iklass, add)
 ("adding previous version ref for %s, EMCP_cnt=%d", scratch_class->external_name(), emcp_method_count);
-// Clean out old previous versions
+// Clean out old previous versions for this class
-purge_previous_versions(this);
+purge_previous_version_list();
 // Mark newly obsolete methods in remaining previous versions.  An EMCP method from
 // a previous redefinition may be made obsolete by this redefinition.
 Array<Method*>* old_methods = scratch_class->methods();
 mark_newly_obsolete_methods(old_methods, emcp_method_count);
 if (!cp_ref->on_stack()) {
 log_trace(redefine, class, iklass, add)("scratch class not added; no methods are running");
 // For debugging purposes.
 scratch_class->set_is_scratch_class();
 scratch_class->class_loader_data()->add_to_deallocate_list(scratch_class());
-// Update count for class unloading.
-_previous_version_count--;
 return;
 }
 if (emcp_method_count != 0) {
 // At least one method is still running, check for EMCP methods
 }
 }
 }
 // Add previous version if any methods are still running.
-log_trace(redefine, class, iklass, add)("scratch class added; one of its methods is on_stack");
+// Set has_previous_version flag for processing during class unloading.
+_has_previous_versions = true;
+log_trace(redefine, class, iklass, add) ("scratch class added; one of its methods is on_stack.");
 assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version");
 scratch_class->link_previous_versions(previous_versions());
 link_previous_versions(scratch_class());
-// Update count for class unloading.
-_previous_version_count++;
 } // end add_previous_version()
 #endif // INCLUDE_JVMTI
 Method* InstanceKlass::method_with_idnum(int idnum) {

changeset 40927	59f3c8a69541
parent 40909	0bb3d95b9577
child 41182	dbd59c1da636