# HG changeset patch # User kbarrett # Date 1429568065 14400 # Mon Apr 20 18:14:25 2015 -0400 # Node ID cb254761634726757ba138df32ad933f82705ab3 # Parent 3ac81daab1ac41f9d295f086e80bc7f9ca81c289 imported patch remove_config diff --git a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp @@ -257,31 +257,18 @@ } } T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); - if (ReferenceProcessor::pending_list_uses_discovered_field()) { - // Treat discovered as normal oop, if ref is not "active", - // i.e. if next is non-NULL. - T next_oop = oopDesc::load_heap_oop(next_addr); - if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" - T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) - PSParallelCompact::mark_and_push(cm, discovered_addr); - } - } else { -#ifdef ASSERT - // In the case of older JDKs which do not use the discovered - // field for the pending list, an inactive ref (next != NULL) - // must always have a NULL discovered field. - T next = oopDesc::load_heap_oop(next_addr); - oop discovered = java_lang_ref_Reference::discovered(obj); - assert(oopDesc::is_null(next) || oopDesc::is_null(discovered), - err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL discovered field", - p2i(obj))); -#endif + // Treat discovered as normal oop, if ref is not "active", + // i.e. if next is non-NULL. + T next_oop = oopDesc::load_heap_oop(next_addr); + if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" + T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); + debug_only( + if(TraceReferenceGC && PrintGCDetails) { + gclog_or_tty->print_cr(" Process discovered as normal " + PTR_FORMAT, p2i(discovered_addr)); + } + ) + PSParallelCompact::mark_and_push(cm, discovered_addr); } PSParallelCompact::mark_and_push(cm, next_addr); klass->InstanceKlass::oop_pc_follow_contents(obj, cm); diff --git a/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp @@ -365,33 +365,19 @@ // Treat discovered as normal oop, if ref is not "active", // i.e. if next is non-NULL. T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); - if (ReferenceProcessor::pending_list_uses_discovered_field()) { - T next_oop = oopDesc::load_heap_oop(next_addr); - if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" - T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) - if (PSScavenge::should_scavenge(discovered_addr)) { - pm->claim_or_forward_depth(discovered_addr); + T next_oop = oopDesc::load_heap_oop(next_addr); + if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" + T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); + debug_only( + if(TraceReferenceGC && PrintGCDetails) { + gclog_or_tty->print_cr(" Process discovered as normal " + PTR_FORMAT, p2i(discovered_addr)); } + ) + if (PSScavenge::should_scavenge(discovered_addr)) { + pm->claim_or_forward_depth(discovered_addr); } - } else { -#ifdef ASSERT - // In the case of older JDKs which do not use the discovered - // field for the pending list, an inactive ref (next != NULL) - // must always have a NULL discovered field. - oop next = oopDesc::load_decode_heap_oop(next_addr); - oop discovered = java_lang_ref_Reference::discovered(obj); - assert(oopDesc::is_null(next) || oopDesc::is_null(discovered), - err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL discovered field", - p2i(obj))); -#endif } - // Treat next as normal oop; next is a link in the reference queue. if (PSScavenge::should_scavenge(next_addr)) { pm->claim_or_forward_depth(next_addr); diff --git a/src/share/vm/gc_implementation/shared/markSweep.cpp b/src/share/vm/gc_implementation/shared/markSweep.cpp --- a/src/share/vm/gc_implementation/shared/markSweep.cpp +++ b/src/share/vm/gc_implementation/shared/markSweep.cpp @@ -145,31 +145,18 @@ } } T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); - if (ReferenceProcessor::pending_list_uses_discovered_field()) { - // Treat discovered as normal oop, if ref is not "active", - // i.e. if next is non-NULL. - T next_oop = oopDesc::load_heap_oop(next_addr); - if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" - T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) - MarkSweep::mark_and_push(discovered_addr); - } - } else { -#ifdef ASSERT - // In the case of older JDKs which do not use the discovered - // field for the pending list, an inactive ref (next != NULL) - // must always have a NULL discovered field. - oop next = oopDesc::load_decode_heap_oop(next_addr); - oop discovered = java_lang_ref_Reference::discovered(obj); - assert(oopDesc::is_null(next) || oopDesc::is_null(discovered), - err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL discovered field", - p2i(obj))); -#endif + // Treat discovered as normal oop, if ref is not "active", + // i.e. if next is non-NULL. + T next_oop = oopDesc::load_heap_oop(next_addr); + if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" + T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); + debug_only( + if(TraceReferenceGC && PrintGCDetails) { + gclog_or_tty->print_cr(" Process discovered as normal " + PTR_FORMAT, p2i(discovered_addr)); + } + ) + MarkSweep::mark_and_push(discovered_addr); } // treat next as normal oop. next is a link in the reference queue. debug_only( diff --git a/src/share/vm/memory/referenceProcessor.cpp b/src/share/vm/memory/referenceProcessor.cpp --- a/src/share/vm/memory/referenceProcessor.cpp +++ b/src/share/vm/memory/referenceProcessor.cpp @@ -37,7 +37,6 @@ ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL; ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy = NULL; -bool ReferenceProcessor::_pending_list_uses_discovered_field = false; jlong ReferenceProcessor::_soft_ref_timestamp_clock = 0; void referenceProcessor_init() { @@ -63,7 +62,6 @@ guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery || RefDiscoveryPolicy == ReferentBasedDiscovery, "Unrecognized RefDiscoveryPolicy"); - _pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field(); } void ReferenceProcessor::enable_discovery(bool check_no_refs) { @@ -353,10 +351,6 @@ // all linked Reference objects. Note that it is important to not dirty any // cards during reference processing since this will cause card table // verification to fail for G1. - // - // BKWRD COMPATIBILITY NOTE: For older JDKs (prior to the fix for 4956777), - // the "next" field is used to chain the pending list, not the discovered - // field. if (TraceReferenceGC && PrintGCDetails) { gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list " INTPTR_FORMAT, p2i(refs_list.head())); @@ -364,64 +358,30 @@ oop obj = NULL; oop next_d = refs_list.head(); - if (pending_list_uses_discovered_field()) { // New behavior - // Walk down the list, self-looping the next field - // so that the References are not considered active. - while (obj != next_d) { - obj = next_d; - assert(obj->is_instanceRef(), "should be reference object"); - next_d = java_lang_ref_Reference::discovered(obj); - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, - p2i(obj), p2i(next_d)); - } - assert(java_lang_ref_Reference::next(obj) == NULL, - "Reference not active; should not be discovered"); - // Self-loop next, so as to make Ref not active. - java_lang_ref_Reference::set_next_raw(obj, obj); - if (next_d != obj) { - oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d); - } else { - // This is the last object. - // Swap refs_list into pending_list_addr and - // set obj's discovered to what we read from pending_list_addr. - oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); - // Need post-barrier on pending_list_addr. See enqueue_discovered_ref_helper() above. - java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL - oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old); - } + // Walk down the list, self-looping the next field + // so that the References are not considered active. + while (obj != next_d) { + obj = next_d; + assert(obj->is_instanceRef(), "should be reference object"); + next_d = java_lang_ref_Reference::discovered(obj); + if (TraceReferenceGC && PrintGCDetails) { + gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, + p2i(obj), p2i(next_d)); } - } else { // Old behavior - // Walk down the list, copying the discovered field into - // the next field and clearing the discovered field. - while (obj != next_d) { - obj = next_d; - assert(obj->is_instanceRef(), "should be reference object"); - next_d = java_lang_ref_Reference::discovered(obj); - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, - p2i(obj), p2i(next_d)); - } - assert(java_lang_ref_Reference::next(obj) == NULL, - "The reference should not be enqueued"); - if (next_d == obj) { // obj is last - // Swap refs_list into pending_list_addr and - // set obj's next to what we read from pending_list_addr. - oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); - // Need oop_check on pending_list_addr above; - // see special oop-check code at the end of - // enqueue_discovered_reflists() further below. - if (old == NULL) { - // obj should be made to point to itself, since - // pending list was empty. - java_lang_ref_Reference::set_next(obj, obj); - } else { - java_lang_ref_Reference::set_next(obj, old); - } - } else { - java_lang_ref_Reference::set_next(obj, next_d); - } - java_lang_ref_Reference::set_discovered(obj, (oop) NULL); + assert(java_lang_ref_Reference::next(obj) == NULL, + "Reference not active; should not be discovered"); + // Self-loop next, so as to make Ref not active. + java_lang_ref_Reference::set_next_raw(obj, obj); + if (next_d != obj) { + oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d); + } else { + // This is the last object. + // Swap refs_list into pending_list_addr and + // set obj's discovered to what we read from pending_list_addr. + oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); + // Need post-barrier on pending_list_addr. See enqueue_discovered_ref_helper() above. + java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL + oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old); } } } @@ -515,22 +475,6 @@ _refs_list.dec_length(1); } -// Make the Reference object active again. -void DiscoveredListIterator::make_active() { - // The pre barrier for G1 is probably just needed for the old - // reference processing behavior. Should we guard this with - // ReferenceProcessor::pending_list_uses_discovered_field() ? - if (UseG1GC) { - HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref); - if (UseCompressedOops) { - oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL); - } else { - oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL); - } - } - java_lang_ref_Reference::set_next_raw(_ref, NULL); -} - void DiscoveredListIterator::clear_referent() { oop_store_raw(_referent_addr, NULL); } @@ -567,8 +511,6 @@ } // Remove Reference object from list iter.remove(); - // Make the Reference object active again - iter.make_active(); // keep the referent around iter.make_referent_alive(); iter.move_to_next(); diff --git a/src/share/vm/memory/referenceProcessor.hpp b/src/share/vm/memory/referenceProcessor.hpp --- a/src/share/vm/memory/referenceProcessor.hpp +++ b/src/share/vm/memory/referenceProcessor.hpp @@ -161,9 +161,6 @@ // Remove the current reference from the list void remove(); - // Make the Reference object active again. - void make_active(); - // Make the referent alive. inline void make_referent_alive() { if (UseCompressedOops) { @@ -200,9 +197,6 @@ size_t total_count(DiscoveredList lists[]); protected: - // Compatibility with pre-4965777 JDK's - static bool _pending_list_uses_discovered_field; - // The SoftReference master timestamp clock static jlong _soft_ref_timestamp_clock; @@ -421,13 +415,6 @@ bool discovery_is_atomic() const { return _discovery_is_atomic; } void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; } - // whether the JDK in which we are embedded is a pre-4965777 JDK, - // and thus whether or not it uses the discovered field to chain - // the entries in the pending list. - static bool pending_list_uses_discovered_field() { - return _pending_list_uses_discovered_field; - } - // whether discovery is done by multiple threads same-old-timeously bool discovery_is_mt() const { return _discovery_is_mt; } void set_mt_discovery(bool mt) { _discovery_is_mt = mt; } diff --git a/src/share/vm/oops/instanceRefKlass.inline.hpp b/src/share/vm/oops/instanceRefKlass.inline.hpp --- a/src/share/vm/oops/instanceRefKlass.inline.hpp +++ b/src/share/vm/oops/instanceRefKlass.inline.hpp @@ -55,30 +55,17 @@ } } T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); - if (ReferenceProcessor::pending_list_uses_discovered_field()) { - T next_oop = oopDesc::load_heap_oop(next_addr); - // Treat discovered as normal oop, if ref is not "active" (next non-NULL) - if (!oopDesc::is_null(next_oop) && contains(disc_addr)) { - // i.e. ref is not "active" - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(disc_addr)); - } - ) - Devirtualizer::do_oop(closure, disc_addr); - } - } else { - // In the case of older JDKs which do not use the discovered field for - // the pending list, an inactive ref (next != NULL) must always have a - // NULL discovered field. + T next_oop = oopDesc::load_heap_oop(next_addr); + // Treat discovered as normal oop, if ref is not "active" (next non-NULL) + if (!oopDesc::is_null(next_oop) && contains(disc_addr)) { + // i.e. ref is not "active" debug_only( - T next_oop = oopDesc::load_heap_oop(next_addr); - T disc_oop = oopDesc::load_heap_oop(disc_addr); - assert(oopDesc::is_null(next_oop) || oopDesc::is_null(disc_oop), - err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL" - "discovered field", p2i(obj))); + if(TraceReferenceGC && PrintGCDetails) { + gclog_or_tty->print_cr(" Process discovered as normal " + PTR_FORMAT, p2i(disc_addr)); + } ) + Devirtualizer::do_oop(closure, disc_addr); } // treat next as normal oop if (contains(next_addr)) { diff --git a/src/share/vm/runtime/java.cpp b/src/share/vm/runtime/java.cpp --- a/src/share/vm/runtime/java.cpp +++ b/src/share/vm/runtime/java.cpp @@ -651,11 +651,15 @@ minor = micro; micro = 0; } + // Incompatible with pre-4243978 JDK. + if (info.pending_list_uses_discovered_field == 0) { + vm_exit_during_initialization( + "Incompatible JDK is not using Reference.discovered field for pending list"); + } _current = JDK_Version(major, minor, micro, info.update_version, info.special_update_version, build, info.thread_park_blocker == 1, - info.post_vm_init_hook_enabled == 1, - info.pending_list_uses_discovered_field == 1); + info.post_vm_init_hook_enabled == 1); } } diff --git a/src/share/vm/runtime/java.hpp b/src/share/vm/runtime/java.hpp --- a/src/share/vm/runtime/java.hpp +++ b/src/share/vm/runtime/java.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -91,7 +91,6 @@ bool _partially_initialized; bool _thread_park_blocker; - bool _pending_list_uses_discovered_field; bool _post_vm_init_hook_enabled; bool is_valid() const { @@ -114,18 +113,17 @@ JDK_Version() : _major(0), _minor(0), _micro(0), _update(0), _special(0), _build(0), _partially_initialized(false), - _thread_park_blocker(false), _post_vm_init_hook_enabled(false), - _pending_list_uses_discovered_field(false) {} + _thread_park_blocker(false), _post_vm_init_hook_enabled(false) + {} JDK_Version(uint8_t major, uint8_t minor = 0, uint8_t micro = 0, uint8_t update = 0, uint8_t special = 0, uint8_t build = 0, - bool thread_park_blocker = false, bool post_vm_init_hook_enabled = false, - bool pending_list_uses_discovered_field = false) : + bool thread_park_blocker = false, bool post_vm_init_hook_enabled = false) : _major(major), _minor(minor), _micro(micro), _update(update), _special(special), _build(build), _partially_initialized(false), _thread_park_blocker(thread_park_blocker), - _post_vm_init_hook_enabled(post_vm_init_hook_enabled), - _pending_list_uses_discovered_field(pending_list_uses_discovered_field) {} + _post_vm_init_hook_enabled(post_vm_init_hook_enabled) + {} // Returns the current running JDK version static JDK_Version current() { return _current; } @@ -152,10 +150,6 @@ bool post_vm_init_hook_enabled() const { return _post_vm_init_hook_enabled; } - // For compatibility wrt pre-4965777 JDK's - bool pending_list_uses_discovered_field() const { - return _pending_list_uses_discovered_field; - } // Performs a full ordering comparison using all fields (update, build, etc.) int compare(const JDK_Version& other) const;