jdk-sandbox: comparison hotspot/src/share/vm/gc

equal deleted inserted replaced

-:90e004691873
+:af4d405aacc1
 _perf_gc_lastcause =
 PerfDataManager::create_string_variable(SUN_GC, "lastCause",
 80, GCCause::to_string(_gc_lastcause), CHECK);
 }
-}
+_defer_initial_card_mark = false; // strengthened by subclass in pre_initialize() below.
+}
+void CollectedHeap::pre_initialize() {
+// Used for ReduceInitialCardMarks (when COMPILER2 is used);
+// otherwise remains unused.
+#ifdef COMPLER2
+_defer_initial_card_mark = ReduceInitialCardMarks && (DeferInitialCardMark || card_mark_must_follow_store());
+#else
+assert(_defer_initial_card_mark == false, "Who would set it?");
+#endif
+}
 #ifndef PRODUCT
 void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
 for (size_t slot = 0; slot < size; slot += 1) {
 }
 void CollectedHeap::flush_deferred_store_barrier(JavaThread* thread) {
 MemRegion deferred = thread->deferred_card_mark();
 if (!deferred.is_empty()) {
+assert(_defer_initial_card_mark, "Otherwise should be empty");
 {
 // Verify that the storage points to a parsable object in heap
 DEBUG_ONLY(oop old_obj = oop(deferred.start());)
 assert(is_in(old_obj), "Not in allocated heap");
 assert(!can_elide_initializing_store_barrier(old_obj),
-"Else should have been filtered in defer_store_barrier()");
+"Else should have been filtered in new_store_pre_barrier()");
 assert(!is_in_permanent(old_obj), "Sanity: not expected");
 assert(old_obj->is_oop(true), "Not an oop");
 assert(old_obj->is_parsable(), "Will not be concurrently parsable");
 assert(deferred.word_size() == (size_t)(old_obj->size()),
 "Mismatch: multiple objects?");
 //     in the old gen, and do not care if the card-mark
 //     succeeds or precedes the initializing stores themselves,
 //     so long as the card-mark is completed before the next
 //     scavenge. For all these cases, we can do a card mark
 //     at the point at which we do a slow path allocation
-//     in the old gen. For uniformity, however, we end
+//     in the old gen, i.e. in this call.
-//     up using the same scheme (see below) for all three
-//     cases (deferring the card-mark appropriately).
 // (b) GenCollectedHeap(ConcurrentMarkSweepGeneration) requires
 //     in addition that the card-mark for an old gen allocated
 //     object strictly follow any associated initializing stores.
 //     In these cases, the memRegion remembered below is
 //     used to card-mark the entire region either just before the next
 //     optionally be refined by the concurrent update threads. Note
 //     that this barrier need only be applied to a non-young write,
 //     but, like in CMS, because of the presence of concurrent refinement
 //     (much like CMS' precleaning), must strictly follow the oop-store.
 //     Thus, using the same protocol for maintaining the intended
-//     invariants turns out, serendepitously, to be the same for all
+//     invariants turns out, serendepitously, to be the same for both
-//     three collectors/heap types above.
+//     G1 and CMS.
 //
-// For each future collector, this should be reexamined with
+// For any future collector, this code should be reexamined with
-// that specific collector in mind.
+// that specific collector in mind, and the documentation above suitably
-oop CollectedHeap::defer_store_barrier(JavaThread* thread, oop new_obj) {
+// extended and updated.
+oop CollectedHeap::new_store_pre_barrier(JavaThread* thread, oop new_obj) {
 // If a previous card-mark was deferred, flush it now.
 flush_deferred_store_barrier(thread);
 if (can_elide_initializing_store_barrier(new_obj)) {
 // The deferred_card_mark region should be empty
 // following the flush above.
 assert(thread->deferred_card_mark().is_empty(), "Error");
 } else {
-// Remember info for the newly deferred store barrier
+MemRegion mr((HeapWord*)new_obj, new_obj->size());
-MemRegion deferred = MemRegion((HeapWord*)new_obj, new_obj->size());
+assert(!mr.is_empty(), "Error");
-assert(!deferred.is_empty(), "Error");
+if (_defer_initial_card_mark) {
-thread->set_deferred_card_mark(deferred);
+// Defer the card mark
+thread->set_deferred_card_mark(mr);
+} else {
+// Do the card mark
+BarrierSet* bs = barrier_set();
+assert(bs->has_write_region_opt(), "No write_region() on BarrierSet");
+bs->write_region(mr);
+}
 }
 return new_obj;
 }
 size_t CollectedHeap::filler_array_hdr_size() {
 }
 HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
 guarantee(false, "thread-local allocation buffers not supported");
 return NULL;
-}
-void CollectedHeap::fill_all_tlabs(bool retire) {
-assert(UseTLAB, "should not reach here");
-// See note in ensure_parsability() below.
-assert(SafepointSynchronize::is_at_safepoint() ||
-!is_init_completed(),
-"should only fill tlabs at safepoint");
-// The main thread starts allocating via a TLAB even before it
-// has added itself to the threads list at vm boot-up.
-assert(Threads::first() != NULL,
-"Attempt to fill tlabs before main thread has been added"
-" to threads list is doomed to failure!");
-for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
-thread->tlab().make_parsable(retire);
-}
 }
 void CollectedHeap::ensure_parsability(bool retire_tlabs) {
 // The second disjunct in the assertion below makes a concession
 // for the start-up verification done while the VM is being
 assert(SafepointSynchronize::is_at_safepoint() ||
 !is_init_completed(),
 "Should only be called at a safepoint or at start-up"
 " otherwise concurrent mutator activity may make heap "
 " unparsable again");
-if (UseTLAB) {
+const bool use_tlab = UseTLAB;
-fill_all_tlabs(retire_tlabs);
+const bool deferred = _defer_initial_card_mark;
+// The main thread starts allocating via a TLAB even before it
+// has added itself to the threads list at vm boot-up.
+assert(!use_tlab || Threads::first() != NULL,
+"Attempt to fill tlabs before main thread has been added"
+" to threads list is doomed to failure!");
+for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
+if (use_tlab) thread->tlab().make_parsable(retire_tlabs);
+#ifdef COMPILER2
+// The deferred store barriers must all have been flushed to the
+// card-table (or other remembered set structure) before GC starts
+// processing the card-table (or other remembered set).
+if (deferred) flush_deferred_store_barrier(thread);
+#else
+assert(!deferred, "Should be false");
+assert(thread->deferred_card_mark().is_empty(), "Should be empty");
+#endif
 }
 }
 void CollectedHeap::accumulate_statistics_all_tlabs() {
 if (UseTLAB) {

changeset 4637	af4d405aacc1
parent 4636	90e004691873
child 4742	9b18850a3185