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

equal deleted inserted replaced

-:ac2d788217ca
+:6258c2e3adfd
 // Do all the safepointing things (allocations) before grabbing the lock.
 // These allocations will have to be freed if they are unused.
 // Allocate a new array of methods.
-jmethodID* to_dealloc_jmeths = NULL;
 jmethodID* new_jmeths = NULL;
 if (length <= idnum) {
 // A new array will be needed (unless some other thread beats us to it)
 size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count());
 new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1);
 memset(new_jmeths, 0, (size+1)*sizeof(jmethodID));
 new_jmeths[0] =(jmethodID)size;  // array size held in the first element
 }
 // Allocate a new method ID.
-jmethodID to_dealloc_id = NULL;
 jmethodID new_id = NULL;
 if (method_h->is_old() && !method_h->is_obsolete()) {
 // The method passed in is old (but not obsolete), we need to use the current version
 methodOop current_method = ik_h->method_with_idnum((int)idnum);
 assert(current_method != NULL, "old and but not obsolete, so should exist");
 // It is the current version of the method or an obsolete method,
 // use the version passed in
 new_id = JNIHandles::make_jmethod_id(method_h);
 }
-{
+if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) {
+// No need and unsafe to lock the JmethodIdCreation_lock at safepoint.
+id = get_jmethod_id(ik_h, idnum, new_id, new_jmeths);
+} else {
 MutexLocker ml(JmethodIdCreation_lock);
+id = get_jmethod_id(ik_h, idnum, new_id, new_jmeths);
-// We must not go to a safepoint while holding this lock.
+}
-debug_only(No_Safepoint_Verifier nosafepoints;)
+}
+return id;
-// Retry lookup after we got the lock
+}
-jmeths = ik_h->methods_jmethod_ids_acquire();
-if (jmeths == NULL || (length = (size_t)jmeths[0]) <= idnum) {
-if (jmeths != NULL) {
+jmethodID instanceKlass::get_jmethod_id(instanceKlassHandle ik_h, size_t idnum,
-// We have grown the array: copy the existing entries, and delete the old array
+jmethodID new_id, jmethodID* new_jmeths) {
-for (size_t index = 0; index < length; index++) {
+// Retry lookup after we got the lock or ensured we are at safepoint
-new_jmeths[index+1] = jmeths[index+1];
+jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
-}
+jmethodID  id                = NULL;
-to_dealloc_jmeths = jmeths; // using the new jmeths, deallocate the old one
+jmethodID  to_dealloc_id     = NULL;
-}
+jmethodID* to_dealloc_jmeths = NULL;
-ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths);
+size_t     length;
-} else {
-id = jmeths[idnum+1];
+if (jmeths == NULL || (length = (size_t)jmeths[0]) <= idnum) {
-to_dealloc_jmeths = new_jmeths; // using the old jmeths, deallocate the new one
+if (jmeths != NULL) {
-}
+// We have grown the array: copy the existing entries, and delete the old array
-if (id == NULL) {
+for (size_t index = 0; index < length; index++) {
-id = new_id;
+new_jmeths[index+1] = jmeths[index+1];
-jmeths[idnum+1] = id;  // install the new method ID
+}
-} else {
+to_dealloc_jmeths = jmeths; // using the new jmeths, deallocate the old one
-to_dealloc_id = new_id; // the new id wasn't used, mark it for deallocation
+}
-}
+ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths);
-}
+} else {
+id = jmeths[idnum+1];
-// Free up unneeded or no longer needed resources
+to_dealloc_jmeths = new_jmeths; // using the old jmeths, deallocate the new one
-FreeHeap(to_dealloc_jmeths);
+}
-if (to_dealloc_id != NULL) {
+if (id == NULL) {
-JNIHandles::destroy_jmethod_id(to_dealloc_id);
+id = new_id;
-}
+jmeths[idnum+1] = id;  // install the new method ID
+} else {
+to_dealloc_id = new_id; // the new id wasn't used, mark it for deallocation
+}
+// Free up unneeded or no longer needed resources
+FreeHeap(to_dealloc_jmeths);
+if (to_dealloc_id != NULL) {
+JNIHandles::destroy_jmethod_id(to_dealloc_id);
 }
 return id;
 }
 // RC_TRACE macro has an embedded ResourceMark
 RC_TRACE(0x00000100, ("adding previous version ref for %s @%d, EMCP_cnt=%d",
 ikh->external_name(), _previous_versions->length(), emcp_method_count));
 constantPoolHandle cp_h(ikh->constants());
-jweak cp_ref = JNIHandles::make_weak_global(cp_h);
+jobject cp_ref;
+if (cp_h->is_shared()) {
+// a shared ConstantPool requires a regular reference; a weak
+// reference would be collectible
+cp_ref = JNIHandles::make_global(cp_h);
+} else {
+cp_ref = JNIHandles::make_weak_global(cp_h);
+}
 PreviousVersionNode * pv_node = NULL;
 objArrayOop old_methods = ikh->methods();
 if (emcp_method_count == 0) {
-pv_node = new PreviousVersionNode(cp_ref, NULL);
+// non-shared ConstantPool gets a weak reference
+pv_node = new PreviousVersionNode(cp_ref, !cp_h->is_shared(), NULL);
 RC_TRACE(0x00000400,
 ("add: all methods are obsolete; flushing any EMCP weak refs"));
 } else {
 int local_count = 0;
 GrowableArray<jweak>* method_refs = new (ResourceObj::C_HEAP)
 // no more EMCP methods so bail out now
 break;
 }
 }
 }
-pv_node = new PreviousVersionNode(cp_ref, method_refs);
+// non-shared ConstantPool gets a weak reference
+pv_node = new PreviousVersionNode(cp_ref, !cp_h->is_shared(), method_refs);
 }
 _previous_versions->append(pv_node);
 // Using weak references allows the interesting parts of previous
 // skip the last entry since we just added it
 for (int i = _previous_versions->length() - 2; i >= 0; i--) {
 // check the previous versions array for a GC'ed weak refs
 pv_node = _previous_versions->at(i);
 cp_ref = pv_node->prev_constant_pool();
-assert(cp_ref != NULL, "weak cp ref was unexpectedly cleared");
+assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
 if (cp_ref == NULL) {
 delete pv_node;
 _previous_versions->remove_at(i);
 // Since we are traversing the array backwards, we don't have to
 // do anything special with the index.
 // skip the last entry since we just added it
 for (int j = _previous_versions->length() - 2; j >= 0; j--) {
 // check the previous versions array for a GC'ed weak refs
 pv_node = _previous_versions->at(j);
 cp_ref = pv_node->prev_constant_pool();
-assert(cp_ref != NULL, "weak cp ref was unexpectedly cleared");
+assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
 if (cp_ref == NULL) {
 delete pv_node;
 _previous_versions->remove_at(j);
 // Since we are traversing the array backwards, we don't have to
 // do anything special with the index.
 for (int i = _previous_versions->length() - 1; i >= 0; i--) {
 // Check the previous versions array for an info node that hasn't
 // been GC'ed
 PreviousVersionNode * pv_node = _previous_versions->at(i);
-jweak cp_ref = pv_node->prev_constant_pool();
+jobject cp_ref = pv_node->prev_constant_pool();
-assert(cp_ref != NULL, "weak reference was unexpectedly cleared");
+assert(cp_ref != NULL, "cp reference was unexpectedly cleared");
 if (cp_ref == NULL) {
 continue;  // robustness
 }
 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);
 } // if no array and idnum isn't included there is nothing to do
 }
 // Construct a PreviousVersionNode entry for the array hung off
 // the instanceKlass.
-PreviousVersionNode::PreviousVersionNode(jweak prev_constant_pool,
+PreviousVersionNode::PreviousVersionNode(jobject prev_constant_pool,
-GrowableArray<jweak>* prev_EMCP_methods) {
+bool prev_cp_is_weak, GrowableArray<jweak>* prev_EMCP_methods) {
 _prev_constant_pool = prev_constant_pool;
+_prev_cp_is_weak = prev_cp_is_weak;
 _prev_EMCP_methods = prev_EMCP_methods;
 }
 // Destroy a PreviousVersionNode
 PreviousVersionNode::~PreviousVersionNode() {
 if (_prev_constant_pool != NULL) {
-JNIHandles::destroy_weak_global(_prev_constant_pool);
+if (_prev_cp_is_weak) {
+JNIHandles::destroy_weak_global(_prev_constant_pool);
+} else {
+JNIHandles::destroy_global(_prev_constant_pool);
+}
 }
 if (_prev_EMCP_methods != NULL) {
 for (int i = _prev_EMCP_methods->length() - 1; i >= 0; i--) {
 jweak method_ref = _prev_EMCP_methods->at(i);
 // Construct a PreviousVersionInfo entry
 PreviousVersionInfo::PreviousVersionInfo(PreviousVersionNode *pv_node) {
 _prev_constant_pool_handle = constantPoolHandle();  // NULL handle
 _prev_EMCP_method_handles = NULL;
-jweak cp_ref = pv_node->prev_constant_pool();
+jobject cp_ref = pv_node->prev_constant_pool();
-assert(cp_ref != NULL, "weak constant pool ref was unexpectedly cleared");
+assert(cp_ref != NULL, "constant pool ref was unexpectedly cleared");
 if (cp_ref == NULL) {
 return;  // robustness
 }
 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);

changeset 225	6258c2e3adfd
parent 217	c646ef2f5d58
parent 222	3d1795325749
child 360	21d113ecbf6a