jdk8-mips64-public/hotspot: comparison src/share/vm/memory/referenceProcessor.cpp

-:00b023ae2d78
+:c96030fff130
 */
 # include "incls/_precompiled.incl"
 # include "incls/_referenceProcessor.cpp.incl"
+ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
+ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;
+oop              ReferenceProcessor::_sentinelRef = NULL;
+const int        subclasses_of_ref                = REF_PHANTOM - REF_OTHER;
 // List of discovered references.
 class DiscoveredList {
 public:
 DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
 oop head() const     {
 oop       _oop_head;
 narrowOop _compressed_head;
 size_t _len;
 };
-oop  ReferenceProcessor::_sentinelRef = NULL;
-const int subclasses_of_ref = REF_PHANTOM - REF_OTHER;
 void referenceProcessor_init() {
 ReferenceProcessor::init_statics();
 }
 void ReferenceProcessor::init_statics() {
 Handle ex(THREAD, PENDING_EXCEPTION);
 vm_exit_during_initialization(ex);
 }
 assert(_sentinelRef != NULL && _sentinelRef->is_oop(),
 "Just constructed it!");
+_always_clear_soft_ref_policy = new AlwaysClearPolicy();
+_default_soft_ref_policy      = new COMPILER2_PRESENT(LRUMaxHeapPolicy())
+NOT_COMPILER2(LRUCurrentHeapPolicy());
+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,
 "Unrecongnized RefDiscoveryPolicy");
 }
 dl_needs_barrier);
 if (rp == NULL) {
 vm_exit_during_initialization("Could not allocate ReferenceProcessor object");
 }
 rp->set_is_alive_non_header(is_alive_non_header);
+rp->snap_policy(false /* default soft ref policy */);
 return rp;
 }
 ReferenceProcessor::ReferenceProcessor(MemRegion span,
 bool      atomic_discovery,
 // Else leave clock stalled at its old value until time progresses
 // past clock value.
 }
 void ReferenceProcessor::process_discovered_references(
-ReferencePolicy*             policy,
 BoolObjectClosure*           is_alive,
 OopClosure*                  keep_alive,
 VoidClosure*                 complete_gc,
 AbstractRefProcTaskExecutor* task_executor) {
 NOT_PRODUCT(verify_ok_to_handle_reflists());
 bool trace_time = PrintGCDetails && PrintReferenceGC;
 // Soft references
 {
 TraceTime tt("SoftReference", trace_time, false, gclog_or_tty);
-process_discovered_reflist(_discoveredSoftRefs, policy, true,
+process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
 is_alive, keep_alive, complete_gc, task_executor);
 }
 update_soft_ref_master_clock();
 // We only enqueue references whose referents are not (yet) strongly
 // reachable.
 if (is_alive_non_header() != NULL) {
 oop referent = java_lang_ref_Reference::referent(obj);
-// We'd like to assert the following:
+// In the case of non-concurrent discovery, the last
-// assert(referent != NULL, "Refs with null referents already filtered");
+// disjunct below should hold. It may not hold in the
-// However, since this code may be executed concurrently with
+// case of concurrent discovery because mutators may
-// mutators, which can clear() the referent, it is not
+// concurrently clear() a Reference.
-// guaranteed that the referent is non-NULL.
+assert(UseConcMarkSweepGC || UseG1GC || referent != NULL,
+"Refs with null referents already filtered");
 if (is_alive_non_header()->do_object_b(referent)) {
 return false;  // referent is reachable
+}
+}
+if (rt == REF_SOFT) {
+// For soft refs we can decide now if these are not
+// current candidates for clearing, in which case we
+// can mark through them now, rather than delaying that
+// to the reference-processing phase. Since all current
+// time-stamp policies advance the soft-ref clock only
+// at a major collection cycle, this is always currently
+// accurate.
+if (!_current_soft_ref_policy->should_clear_reference(obj)) {
+return false;
 }
 }
 HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
 const oop  discovered = java_lang_ref_Reference::discovered(obj);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/referenceProcessor.cpp

src/share/vm/memory/referenceProcessor.cpp