--- a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp Fri Jan 10 12:54:08 2014 -0800
+++ b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp Tue Jan 14 14:26:43 2014 +0100
@@ -219,58 +219,52 @@
}
#ifdef ASSERT
-void SATBMarkQueueSet::dump_active_values(JavaThread* first,
- bool expected_active) {
- gclog_or_tty->print_cr("SATB queue active values for Java Threads");
- gclog_or_tty->print_cr(" SATB queue set: active is %s",
- (is_active()) ? "TRUE" : "FALSE");
- gclog_or_tty->print_cr(" expected_active is %s",
- (expected_active) ? "TRUE" : "FALSE");
- for (JavaThread* t = first; t; t = t->next()) {
- bool active = t->satb_mark_queue().is_active();
- gclog_or_tty->print_cr(" thread %s, active is %s",
- t->name(), (active) ? "TRUE" : "FALSE");
+void SATBMarkQueueSet::dump_active_states(bool expected_active) {
+ gclog_or_tty->print_cr("Expected SATB active state: %s",
+ expected_active ? "ACTIVE" : "INACTIVE");
+ gclog_or_tty->print_cr("Actual SATB active states:");
+ gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
+ for (JavaThread* t = Threads::first(); t; t = t->next()) {
+ gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(),
+ t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
+ }
+ gclog_or_tty->print_cr(" Shared queue: %s",
+ shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
+}
+
+void SATBMarkQueueSet::verify_active_states(bool expected_active) {
+ // Verify queue set state
+ if (is_active() != expected_active) {
+ dump_active_states(expected_active);
+ guarantee(false, "SATB queue set has an unexpected active state");
+ }
+
+ // Verify thread queue states
+ for (JavaThread* t = Threads::first(); t; t = t->next()) {
+ if (t->satb_mark_queue().is_active() != expected_active) {
+ dump_active_states(expected_active);
+ guarantee(false, "Thread SATB queue has an unexpected active state");
+ }
+ }
+
+ // Verify shared queue state
+ if (shared_satb_queue()->is_active() != expected_active) {
+ dump_active_states(expected_active);
+ guarantee(false, "Shared SATB queue has an unexpected active state");
}
}
#endif // ASSERT
-void SATBMarkQueueSet::set_active_all_threads(bool b,
- bool expected_active) {
+void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
- JavaThread* first = Threads::first();
-
#ifdef ASSERT
- if (_all_active != expected_active) {
- dump_active_values(first, expected_active);
-
- // I leave this here as a guarantee, instead of an assert, so
- // that it will still be compiled in if we choose to uncomment
- // the #ifdef ASSERT in a product build. The whole block is
- // within an #ifdef ASSERT so the guarantee will not be compiled
- // in a product build anyway.
- guarantee(false,
- "SATB queue set has an unexpected active value");
- }
+ verify_active_states(expected_active);
#endif // ASSERT
- _all_active = b;
-
- for (JavaThread* t = first; t; t = t->next()) {
-#ifdef ASSERT
- bool active = t->satb_mark_queue().is_active();
- if (active != expected_active) {
- dump_active_values(first, expected_active);
-
- // I leave this here as a guarantee, instead of an assert, so
- // that it will still be compiled in if we choose to uncomment
- // the #ifdef ASSERT in a product build. The whole block is
- // within an #ifdef ASSERT so the guarantee will not be compiled
- // in a product build anyway.
- guarantee(false,
- "thread has an unexpected active value in its SATB queue");
- }
-#endif // ASSERT
- t->satb_mark_queue().set_active(b);
+ _all_active = active;
+ for (JavaThread* t = Threads::first(); t; t = t->next()) {
+ t->satb_mark_queue().set_active(active);
}
+ shared_satb_queue()->set_active(active);
}
void SATBMarkQueueSet::filter_thread_buffers() {
--- a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.hpp Fri Jan 10 12:54:08 2014 -0800
+++ b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.hpp Tue Jan 14 14:26:43 2014 +0100
@@ -87,7 +87,8 @@
bool apply_closure_to_completed_buffer_work(bool par, int worker);
#ifdef ASSERT
- void dump_active_values(JavaThread* first, bool expected_active);
+ void dump_active_states(bool expected_active);
+ void verify_active_states(bool expected_active);
#endif // ASSERT
public:
@@ -99,11 +100,11 @@
static void handle_zero_index_for_thread(JavaThread* t);
- // Apply "set_active(b)" to all Java threads' SATB queues. It should be
+ // Apply "set_active(active)" to all SATB queues in the set. It should be
// called only with the world stopped. The method will assert that the
// SATB queues of all threads it visits, as well as the SATB queue
// set itself, has an active value same as expected_active.
- void set_active_all_threads(bool b, bool expected_active);
+ void set_active_all_threads(bool active, bool expected_active);
// Filter all the currently-active SATB buffers.
void filter_thread_buffers();
--- a/hotspot/src/share/vm/memory/referenceProcessor.cpp Fri Jan 10 12:54:08 2014 -0800
+++ b/hotspot/src/share/vm/memory/referenceProcessor.cpp Tue Jan 14 14:26:43 2014 +0100
@@ -100,7 +100,6 @@
_enqueuing_is_done(false),
_is_alive_non_header(is_alive_non_header),
_discovered_list_needs_barrier(discovered_list_needs_barrier),
- _bs(NULL),
_processing_is_mt(mt_processing),
_next_id(0)
{
@@ -126,10 +125,6 @@
_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 */);
}
@@ -317,13 +312,9 @@
// 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 oop-check on pending_list_addr missed in
- // enqueue_discovered_reflist. We should probably
- // 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));
+ // Do the post-barrier on pending_list_addr missed in
+ // enqueue_discovered_reflist.
+ oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
// Stop treating discovered references specially.
ref->disable_discovery();
@@ -372,15 +363,17 @@
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(obj, obj);
+ // Post-barrier not needed when looping to self.
+ java_lang_ref_Reference::set_next_raw(obj, obj);
if (next_d == obj) { // obj is last
// 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 oop_check on pending_list_addr above;
- // see special oop-check code at the end of
+ // Need post-barrier on pending_list_addr above;
+ // see special post-barrier code at the end of
// enqueue_discovered_reflists() further below.
- java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL
+ 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);
}
}
} else { // Old behaviour
@@ -516,13 +509,11 @@
// 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) {
- bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
+ oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
} else {
- bs->write_ref_field_pre((oop*)next_addr, NULL);
+ oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
}
java_lang_ref_Reference::set_next_raw(_ref, NULL);
} else {
@@ -790,10 +781,9 @@
};
void ReferenceProcessor::set_discovered(oop ref, oop value) {
+ java_lang_ref_Reference::set_discovered_raw(ref, value);
if (_discovered_list_needs_barrier) {
- java_lang_ref_Reference::set_discovered(ref, value);
- } else {
- java_lang_ref_Reference::set_discovered_raw(ref, value);
+ oopDesc::bs()->write_ref_field(ref, value);
}
}
@@ -1085,7 +1075,7 @@
// 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.:-
- // _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
+ // oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(!_discovered_list_needs_barrier || UseG1GC,
"Need to check non-G1 collector: "
"may need a pre-write-barrier for CAS from NULL below");
@@ -1098,7 +1088,7 @@
refs_list.set_head(obj);
refs_list.inc_length(1);
if (_discovered_list_needs_barrier) {
- _bs->write_ref_field((void*)discovered_addr, next_discovered);
+ oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
if (TraceReferenceGC) {
@@ -1260,13 +1250,13 @@
// 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.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
+ // e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(discovered == NULL, "control point invariant");
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_barrier) {
- _bs->write_ref_field((void*)discovered_addr, next_discovered);
+ oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
list->set_head(obj);
list->inc_length(1);
--- a/hotspot/src/share/vm/memory/referenceProcessor.hpp Fri Jan 10 12:54:08 2014 -0800
+++ b/hotspot/src/share/vm/memory/referenceProcessor.hpp Tue Jan 14 14:26:43 2014 +0100
@@ -235,7 +235,6 @@
// discovery.)
bool _discovered_list_needs_barrier;
- BarrierSet* _bs; // Cached copy of BarrierSet.
bool _enqueuing_is_done; // true if all weak references enqueued
bool _processing_is_mt; // true during phases when
// reference processing is MT.
@@ -420,25 +419,6 @@
void update_soft_ref_master_clock();
public:
- // constructor
- ReferenceProcessor():
- _span((HeapWord*)NULL, (HeapWord*)NULL),
- _discovered_refs(NULL),
- _discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL),
- _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
- _discovering_refs(false),
- _discovery_is_atomic(true),
- _enqueuing_is_done(false),
- _discovery_is_mt(false),
- _discovered_list_needs_barrier(false),
- _bs(NULL),
- _is_alive_non_header(NULL),
- _num_q(0),
- _max_num_q(0),
- _processing_is_mt(false),
- _next_id(0)
- { }
-
// Default parameters give you a vanilla reference processor.
ReferenceProcessor(MemRegion span,
bool mt_processing = false, uint mt_processing_degree = 1,