src/share/vm/gc/shared/referenceProcessor.cpp

rev 12906 : [mq]: gc_interface

*** 33,42 ****
--- 33,43 ----
  #include "gc/shared/referenceProcessor.inline.hpp"
  #include "logging/log.hpp"
  #include "memory/allocation.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/oop.inline.hpp"
+ #include "runtime/access.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/jniHandles.hpp"
  
  ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
  ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;
*** 324,343 ****
      next_d = java_lang_ref_Reference::discovered(obj);
      log_develop_trace(gc, ref)("        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 and set obj's
        // discovered to what we read from the pending list.
        oop old = Universe::swap_reference_pending_list(refs_list.head());
!       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);
      }
    }
  }
  
  // Parallel enqueue task
--- 325,343 ----
      next_d = java_lang_ref_Reference::discovered(obj);
      log_develop_trace(gc, ref)("        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.
!     HeapAccess<>::oop_store_at(obj, java_lang_ref_Reference::next_offset, obj);
      if (next_d != obj) {
!       HeapAccess<VALUE_NOT_NULL>::oop_store_at(obj, java_lang_ref_Reference::discovered_offset, next_d);
      } else {
        // This is the last object.
        // Swap refs_list into pending list and set obj's
        // discovered to what we read from the pending list.
        oop old = Universe::swap_reference_pending_list(refs_list.head());
!       HeapAccess<>::oop_store_at(obj, java_lang_ref_Reference::discovered_offset, old);
      }
    }
  }
  
  // Parallel enqueue task
*** 402,412 ****
           p2i(_referent));
  }
  
  void DiscoveredListIterator::remove() {
    assert(_ref->is_oop(), "Dropping a bad reference");
!   oop_store_raw(_discovered_addr, NULL);
  
    // First _prev_next ref actually points into DiscoveredList (gross).
    oop new_next;
    if (_next == _ref) {
      // At the end of the list, we should make _prev point to itself.
--- 402,412 ----
           p2i(_referent));
  }
  
  void DiscoveredListIterator::remove() {
    assert(_ref->is_oop(), "Dropping a bad reference");
!   BasicAccess<>::oop_store(_discovered_addr, oop(NULL));
  
    // First _prev_next ref actually points into DiscoveredList (gross).
    oop new_next;
    if (_next == _ref) {
      // At the end of the list, we should make _prev point to itself.
*** 417,433 ****
      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,
    // that's how it ended up in the discovered list in the first place.
!   oop_store_raw(_prev_next, new_next);
    NOT_PRODUCT(_removed++);
    _refs_list.dec_length(1);
  }
  
  void DiscoveredListIterator::clear_referent() {
!   oop_store_raw(_referent_addr, NULL);
  }
  
  // NOTE: process_phase*() are largely similar, and at a high level
  // merely iterate over the extant list applying a predicate to
  // each of its elements and possibly removing that element from the
--- 417,433 ----
      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,
    // that's how it ended up in the discovered list in the first place.
!   BasicAccess<>::oop_store(_prev_next, new_next);
    NOT_PRODUCT(_removed++);
    _refs_list.dec_length(1);
  }
  
  void DiscoveredListIterator::clear_referent() {
!   BasicAccess<>::oop_store(_referent_addr, oop(NULL));
  }
  
  // NOTE: process_phase*() are largely similar, and at a high level
  // merely iterate over the extant list applying a predicate to
  // each of its elements and possibly removing that element from the
*** 889,900 ****
    // discovered_addr.
    oop current_head = refs_list.head();
    // The last ref must have its discovered field pointing to itself.
    oop next_discovered = (current_head != NULL) ? current_head : obj;
  
!   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);
--- 889,900 ----
    // discovered_addr.
    oop current_head = refs_list.head();
    // The last ref must have its discovered field pointing to itself.
    oop next_discovered = (current_head != NULL) ? current_head : obj;
  
!   oop retest = HeapAccess<MO_SEQ_CST | ACCESS_WEAK>::oop_cas(next_discovered, discovered_addr, oop(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);
*** 1048,1058 ****
      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;
  
      assert(discovered == NULL, "control point invariant");
!     oop_store_raw(discovered_addr, next_discovered);
      list->set_head(obj);
      list->inc_length(1);
  
      log_develop_trace(gc, ref)("Discovered reference (" INTPTR_FORMAT ": %s)", p2i(obj), obj->klass()->internal_name());
    }
--- 1048,1058 ----
      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;
  
      assert(discovered == NULL, "control point invariant");
!     BasicAccess<>::oop_store(discovered_addr, next_discovered);
      list->set_head(obj);
      list->inc_length(1);
  
      log_develop_trace(gc, ref)("Discovered reference (" INTPTR_FORMAT ": %s)", p2i(obj), obj->klass()->internal_name());
    }
*** 1194,1199 ****
       case 3: return "PhantomRef";
     }
     ShouldNotReachHere();
     return NULL;
  }
- 
--- 1194,1198 ----