graal-compiler: src/share/vm/memory/referenceProcessor.cpp comparison

comparison src/share/vm/memory/referenceProcessor.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	d8041d695d19
children	52b4284cb496

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 void referenceProcessor_init() {
 ReferenceProcessor::init_statics();
 }
 void ReferenceProcessor::init_statics() {
-// We need a monotonically non-decreasing time in ms but
+// We need a monotonically non-deccreasing time in ms but
 // os::javaTimeMillis() does not guarantee monotonicity.
 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 // Initialize the soft ref timestamp clock.
 _soft_ref_timestamp_clock = now;
 if (_always_clear_soft_ref_policy == NULL || _default_soft_ref_policy == NULL) {
 vm_exit_during_initialization("Could not allocate reference policy object");
 }
 guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery ||
 RefDiscoveryPolicy == ReferentBasedDiscovery,
-"Unrecognized RefDiscoveryPolicy");
+"Unrecongnized RefDiscoveryPolicy");
 _pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field();
 }
 void ReferenceProcessor::enable_discovery(bool verify_disabled, bool check_no_refs) {
 #ifdef ASSERT
 uint      mt_processing_degree,
 bool      mt_discovery,
 uint      mt_discovery_degree,
 bool      atomic_discovery,
 BoolObjectClosure* is_alive_non_header,
-bool      discovered_list_needs_post_barrier)  :
+bool      discovered_list_needs_barrier)  :
 _discovering_refs(false),
 _enqueuing_is_done(false),
 _is_alive_non_header(is_alive_non_header),
-_discovered_list_needs_post_barrier(discovered_list_needs_post_barrier),
+_discovered_list_needs_barrier(discovered_list_needs_barrier),
+_bs(NULL),
 _processing_is_mt(mt_processing),
 _next_id(0)
 {
 _span = span;
 _discovery_is_atomic = atomic_discovery;
 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 _discovered_refs[i].set_head(NULL);
 _discovered_refs[i].set_length(0);
 }
+// If we do barriers, cache a copy of the barrier set.
+if (discovered_list_needs_barrier) {
+_bs = Universe::heap()->barrier_set();
+}
 setup_policy(false /* default soft ref policy */);
 }
 #ifndef PRODUCT
 void ReferenceProcessor::verify_no_references_recorded() {
 void ReferenceProcessor::update_soft_ref_master_clock() {
 // Update (advance) the soft ref master clock field. This must be done
 // after processing the soft ref list.
-// We need a monotonically non-decreasing time in ms but
+// We need a monotonically non-deccreasing time in ms but
 // os::javaTimeMillis() does not guarantee monotonicity.
 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
 assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
 )
 // The values of now and _soft_ref_timestamp_clock are set using
 // javaTimeNanos(), which is guaranteed to be monotonically
 // non-decreasing provided the underlying platform provides such
 // a time source (and it is bug free).
-// In product mode, however, protect ourselves from non-monotonicity.
+// In product mode, however, protect ourselves from non-monotonicty.
 if (now > _soft_ref_timestamp_clock) {
 _soft_ref_timestamp_clock = now;
 java_lang_ref_SoftReference::set_clock(now);
 }
 // Else leave clock stalled at its old value until time progresses
 T old_pending_list_value = *pending_list_addr;
 // Enqueue references that are not made active again, and
 // clear the decks for the next collection (cycle).
 ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
-// Do the post-barrier on pending_list_addr missed in
+// Do the oop-check on pending_list_addr missed in
-// enqueue_discovered_reflist.
+// enqueue_discovered_reflist. We should probably
-oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
+// do a raw oop_check so that future such idempotent
+// oop_stores relying on the oop-check side-effect
+// may be elided automatically and safely without
+// affecting correctness.
+oop_store(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
 // Stop treating discovered references specially.
 ref->disable_discovery();
 // Return true if new pending references were added
 INTPTR_FORMAT, (address)refs_list.head());
 }
 oop obj = NULL;
 oop next_d = refs_list.head();
-if (pending_list_uses_discovered_field()) { // New behavior
+if (pending_list_uses_discovered_field()) { // New behaviour
 // 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");
 (void *)obj, (void *)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.
-// Post-barrier not needed when looping to self.
+java_lang_ref_Reference::set_next(obj, obj);
-java_lang_ref_Reference::set_next_raw(obj, obj);
 if (next_d == obj) {  // obj is last
-// Swap refs_list into pending_list_addr and
+// Swap refs_list into pendling_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 above;
+// Need oop_check on pending_list_addr above;
-// see special post-barrier code at the end of
+// see special oop-check code at the end of
 // enqueue_discovered_reflists() further below.
-java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
+java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL
-oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
 }
 }
-} else { // Old behavior
+} else { // Old behaviour
 // 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");
 (void *)obj, (void *)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
+// Swap refs_list into pendling_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.
 // and _prev will be NULL.
 new_next = _prev;
 } else {
 new_next = _next;
 }
-// Remove Reference object from discovered list. Note that G1 does not need a
-// pre-barrier here because we know the Reference has already been found/marked,
+if (UseCompressedOops) {
-// that's how it ended up in the discovered list in the first place.
+// Remove Reference object from list.
-oop_store_raw(_prev_next, new_next);
+oopDesc::encode_store_heap_oop((narrowOop*)_prev_next, new_next);
-if (_discovered_list_needs_post_barrier && _prev_next != _refs_list.adr_head()) {
+} else {
-// Needs post-barrier and this is not the list head (which is not on the heap)
+// Remove Reference object from list.
-oopDesc::bs()->write_ref_field(_prev_next, new_next);
+oopDesc::store_heap_oop((oop*)_prev_next, new_next);
 }
 NOT_PRODUCT(_removed++);
 _refs_list.dec_length(1);
 }
 // For G1 we don't want to use set_next - it
 // will dirty the card for the next field of
 // the reference object and will fail
 // CT verification.
 if (UseG1GC) {
+BarrierSet* bs = oopDesc::bs();
 HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
 if (UseCompressedOops) {
-oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
+bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
 } else {
-oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
+bs->write_ref_field_pre((oop*)next_addr, NULL);
 }
 java_lang_ref_Reference::set_next_raw(_ref, NULL);
 } else {
 java_lang_ref_Reference::set_next(_ref, NULL);
 }
 ReferencePolicy*   policy,
 BoolObjectClosure* is_alive,
 OopClosure*        keep_alive,
 VoidClosure*       complete_gc) {
 assert(policy != NULL, "Must have a non-NULL policy");
-DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 // Decide which softly reachable refs should be kept alive.
 while (iter.has_next()) {
 iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
 bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
 if (referent_is_dead &&
 void
 ReferenceProcessor::pp2_work(DiscoveredList&    refs_list,
 BoolObjectClosure* is_alive,
 OopClosure*        keep_alive) {
 assert(discovery_is_atomic(), "Error");
-DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 while (iter.has_next()) {
 iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
 DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
 assert(next == NULL, "Should not discover inactive Reference");
 if (iter.is_referent_alive()) {
 ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList&    refs_list,
 BoolObjectClosure* is_alive,
 OopClosure*        keep_alive,
 VoidClosure*       complete_gc) {
 assert(!discovery_is_atomic(), "Error");
-DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 while (iter.has_next()) {
 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
 HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
 oop next = java_lang_ref_Reference::next(iter.obj());
 if ((iter.referent() == NULL || iter.is_referent_alive() ||
 bool               clear_referent,
 BoolObjectClosure* is_alive,
 OopClosure*        keep_alive,
 VoidClosure*       complete_gc) {
 ResourceMark rm;
-DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 while (iter.has_next()) {
 iter.update_discovered();
 iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
 if (clear_referent) {
 // NULL out referent pointer
 private:
 bool _clear_referent;
 };
 void ReferenceProcessor::set_discovered(oop ref, oop value) {
-java_lang_ref_Reference::set_discovered_raw(ref, value);
+if (_discovered_list_needs_barrier) {
-if (_discovered_list_needs_post_barrier) {
+java_lang_ref_Reference::set_discovered(ref, value);
-oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(ref), value);
+} else {
+java_lang_ref_Reference::set_discovered_raw(ref, value);
 }
 }
 // Balances reference queues.
 // Move entries from all queues[0, 1, ..., _max_num_q-1] to
 }
 }
 void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
 assert(!discovery_is_atomic(), "Else why call this method?");
-DiscoveredListIterator iter(refs_list, NULL, NULL, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, NULL, NULL);
 while (iter.has_next()) {
 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
 oop next = java_lang_ref_Reference::next(iter.obj());
 assert(next->is_oop_or_null(), "bad next field");
 // If referent has been cleared or Reference is not active,
 // not necessary because the only case we are interested in
 // here is when *discovered_addr is NULL (see the CAS further below),
 // so this will expand to nothing. As a result, we have manually
 // elided this out for G1, but left in the test for some future
 // collector that might have need for a pre-barrier here, e.g.:-
-// oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
+// _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
-assert(!_discovered_list_needs_post_barrier || UseG1GC,
+assert(!_discovered_list_needs_barrier || UseG1GC,
 "Need to check non-G1 collector: "
 "may need a pre-write-barrier for CAS from NULL below");
 oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
 NULL);
 if (retest == NULL) {
 // This thread just won the right to enqueue the object.
 // We have separate lists for enqueueing, so no synchronization
 // is necessary.
 refs_list.set_head(obj);
 refs_list.inc_length(1);
-if (_discovered_list_needs_post_barrier) {
+if (_discovered_list_needs_barrier) {
-oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
+_bs->write_ref_field((void*)discovered_addr, next_discovered);
 }
 if (TraceReferenceGC) {
 gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
 (void *)obj, obj->klass()->internal_name());
 }
 if (_discovery_is_mt) {
 add_to_discovered_list_mt(*list, obj, discovered_addr);
 } else {
-// If "_discovered_list_needs_post_barrier", we do write barriers when
+// If "_discovered_list_needs_barrier", we do write barriers when
 // updating the discovered reference list.  Otherwise, we do a raw store
 // here: the field will be visited later when processing the discovered
 // references.
 oop current_head = list->head();
 // The last ref must have its discovered field pointing to itself.
 oop next_discovered = (current_head != NULL) ? current_head : obj;
 // As in the case further above, since we are over-writing a NULL
 // pre-value, we can safely elide the pre-barrier here for the case of G1.
-// e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
+// e.g.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
 assert(discovered == NULL, "control point invariant");
-assert(!_discovered_list_needs_post_barrier || UseG1GC,
+assert(!_discovered_list_needs_barrier || UseG1GC,
 "For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
 oop_store_raw(discovered_addr, next_discovered);
-if (_discovered_list_needs_post_barrier) {
+if (_discovered_list_needs_barrier) {
-oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
+_bs->write_ref_field((void*)discovered_addr, next_discovered);
 }
 list->set_head(obj);
 list->inc_length(1);
 if (TraceReferenceGC) {
 // Walk the given discovered ref list, and remove all reference objects
 // whose referents are still alive, whose referents are NULL or which
 // are not active (have a non-NULL next field). NOTE: When we are
 // thus precleaning the ref lists (which happens single-threaded today),
-// we do not disable refs discovery to honor the correct semantics of
+// we do not disable refs discovery to honour the correct semantics of
 // java.lang.Reference. As a result, we need to be careful below
 // that ref removal steps interleave safely with ref discovery steps
 // (in this thread).
 void
 ReferenceProcessor::preclean_discovered_reflist(DiscoveredList&    refs_list,
 BoolObjectClosure* is_alive,
 OopClosure*        keep_alive,
 VoidClosure*       complete_gc,
 YieldClosure*      yield) {
-DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
+DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 while (iter.has_next()) {
 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
 oop obj = iter.obj();
 oop next = java_lang_ref_Reference::next(obj);
 if (iter.referent() == NULL || iter.is_referent_alive() ||

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/referenceProcessor.cpp @ 14909:4ca6dc0799b6