--- old/src/share/vm/gc/shared/cardTableModRefBS.cpp 2017-04-25 16:45:03.299174207 +0200 +++ new/src/share/vm/gc/shared/cardTableModRefBS.cpp 2017-04-25 16:45:03.127174213 +0200 @@ -23,507 +23,178 @@ */ #include "precompiled.hpp" +#include "gc/shared/cardTableModRefBSCodeGen.hpp" +#include "gc/shared/c1CardTableModRefBSCodeGen.hpp" +#include "gc/shared/c2CardTableModRefBSCodeGen.hpp" #include "gc/shared/cardTableModRefBS.inline.hpp" -#include "gc/shared/collectedHeap.hpp" -#include "gc/shared/genCollectedHeap.hpp" -#include "gc/shared/space.inline.hpp" -#include "memory/virtualspace.hpp" -#include "logging/log.hpp" -#include "services/memTracker.hpp" -#include "utilities/macros.hpp" // This kind of "BarrierSet" allows a "CollectedHeap" to detect and // enumerate ref fields that have been modified (since the last // enumeration.) -size_t CardTableModRefBS::compute_byte_map_size() -{ - assert(_guard_index == cards_required(_whole_heap.word_size()) - 1, - "uninitialized, check declaration order"); - assert(_page_size != 0, "uninitialized, check declaration order"); - const size_t granularity = os::vm_allocation_granularity(); - return align_size_up(_guard_index + 1, MAX2(_page_size, granularity)); +void CardTableModRefBS::write_region(MemRegion mr) { + _card_table->dirty_MemRegion(mr); } -CardTableModRefBS::CardTableModRefBS( - MemRegion whole_heap, - const BarrierSet::FakeRtti& fake_rtti) : - ModRefBarrierSet(fake_rtti.add_tag(BarrierSet::CardTableModRef)), - _whole_heap(whole_heap), - _guard_index(0), - _guard_region(), - _last_valid_index(0), - _page_size(os::vm_page_size()), - _byte_map_size(0), - _covered(NULL), - _committed(NULL), - _cur_covered_regions(0), - _byte_map(NULL), - byte_map_base(NULL) -{ - assert((uintptr_t(_whole_heap.start()) & (card_size - 1)) == 0, "heap must start at card boundary"); - assert((uintptr_t(_whole_heap.end()) & (card_size - 1)) == 0, "heap must end at card boundary"); - - assert(card_size <= 512, "card_size must be less than 512"); // why? - - _covered = new MemRegion[_max_covered_regions]; - if (_covered == NULL) { - vm_exit_during_initialization("Could not allocate card table covered region set."); - } +void CardTableModRefBS::write_ref_array_region(MemRegion mr) { + _card_table->dirty_MemRegion(mr); } -void CardTableModRefBS::initialize() { - _guard_index = cards_required(_whole_heap.word_size()) - 1; - _last_valid_index = _guard_index - 1; - - _byte_map_size = compute_byte_map_size(); - - HeapWord* low_bound = _whole_heap.start(); - HeapWord* high_bound = _whole_heap.end(); - - _cur_covered_regions = 0; - _committed = new MemRegion[_max_covered_regions]; - if (_committed == NULL) { - vm_exit_during_initialization("Could not allocate card table committed region set."); - } - - const size_t rs_align = _page_size == (size_t) os::vm_page_size() ? 0 : - MAX2(_page_size, (size_t) os::vm_allocation_granularity()); - ReservedSpace heap_rs(_byte_map_size, rs_align, false); - - MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtGC); - - os::trace_page_sizes("Card Table", _guard_index + 1, _guard_index + 1, - _page_size, heap_rs.base(), heap_rs.size()); - if (!heap_rs.is_reserved()) { - vm_exit_during_initialization("Could not reserve enough space for the " - "card marking array"); - } - - // The assembler store_check code will do an unsigned shift of the oop, - // then add it to byte_map_base, i.e. - // - // _byte_map = byte_map_base + (uintptr_t(low_bound) >> card_shift) - _byte_map = (jbyte*) heap_rs.base(); - byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift); - assert(byte_for(low_bound) == &_byte_map[0], "Checking start of map"); - assert(byte_for(high_bound-1) <= &_byte_map[_last_valid_index], "Checking end of map"); - - jbyte* guard_card = &_byte_map[_guard_index]; - uintptr_t guard_page = align_size_down((uintptr_t)guard_card, _page_size); - _guard_region = MemRegion((HeapWord*)guard_page, _page_size); - os::commit_memory_or_exit((char*)guard_page, _page_size, _page_size, - !ExecMem, "card table last card"); - *guard_card = last_card; - - log_trace(gc, barrier)("CardTableModRefBS::CardTableModRefBS: "); - log_trace(gc, barrier)(" &_byte_map[0]: " INTPTR_FORMAT " &_byte_map[_last_valid_index]: " INTPTR_FORMAT, - p2i(&_byte_map[0]), p2i(&_byte_map[_last_valid_index])); - log_trace(gc, barrier)(" byte_map_base: " INTPTR_FORMAT, p2i(byte_map_base)); +BarrierSetCodeGen* CardTableModRefBS::make_code_gen() { + return new CardTableModRefBSCodeGen(); } -CardTableModRefBS::~CardTableModRefBS() { - if (_covered) { - delete[] _covered; - _covered = NULL; - } - if (_committed) { - delete[] _committed; - _committed = NULL; - } +C1BarrierSetCodeGen* CardTableModRefBS::make_c1_code_gen() { + return new C1CardTableModRefBSCodeGen(); } -int CardTableModRefBS::find_covering_region_by_base(HeapWord* base) { - int i; - for (i = 0; i < _cur_covered_regions; i++) { - if (_covered[i].start() == base) return i; - if (_covered[i].start() > base) break; - } - // If we didn't find it, create a new one. - assert(_cur_covered_regions < _max_covered_regions, - "too many covered regions"); - // Move the ones above up, to maintain sorted order. - for (int j = _cur_covered_regions; j > i; j--) { - _covered[j] = _covered[j-1]; - _committed[j] = _committed[j-1]; - } - int res = i; - _cur_covered_regions++; - _covered[res].set_start(base); - _covered[res].set_word_size(0); - jbyte* ct_start = byte_for(base); - uintptr_t ct_start_aligned = align_size_down((uintptr_t)ct_start, _page_size); - _committed[res].set_start((HeapWord*)ct_start_aligned); - _committed[res].set_word_size(0); - return res; +C2BarrierSetCodeGen* CardTableModRefBS::make_c2_code_gen() { + return new C2CardTableModRefBSCodeGen(); } -int CardTableModRefBS::find_covering_region_containing(HeapWord* addr) { - for (int i = 0; i < _cur_covered_regions; i++) { - if (_covered[i].contains(addr)) { - return i; - } - } - assert(0, "address outside of heap?"); - return -1; -} - -HeapWord* CardTableModRefBS::largest_prev_committed_end(int ind) const { - HeapWord* max_end = NULL; - for (int j = 0; j < ind; j++) { - HeapWord* this_end = _committed[j].end(); - if (this_end > max_end) max_end = this_end; - } - return max_end; -} - -MemRegion CardTableModRefBS::committed_unique_to_self(int self, - MemRegion mr) const { - MemRegion result = mr; - for (int r = 0; r < _cur_covered_regions; r += 1) { - if (r != self) { - result = result.minus(_committed[r]); - } - } - // Never include the guard page. - result = result.minus(_guard_region); - return result; -} - -void CardTableModRefBS::resize_covered_region(MemRegion new_region) { - // We don't change the start of a region, only the end. - assert(_whole_heap.contains(new_region), - "attempt to cover area not in reserved area"); - debug_only(verify_guard();) - // collided is true if the expansion would push into another committed region - debug_only(bool collided = false;) - int const ind = find_covering_region_by_base(new_region.start()); - MemRegion const old_region = _covered[ind]; - assert(old_region.start() == new_region.start(), "just checking"); - if (new_region.word_size() != old_region.word_size()) { - // Commit new or uncommit old pages, if necessary. - MemRegion cur_committed = _committed[ind]; - // Extend the end of this _committed region - // to cover the end of any lower _committed regions. - // This forms overlapping regions, but never interior regions. - HeapWord* const max_prev_end = largest_prev_committed_end(ind); - if (max_prev_end > cur_committed.end()) { - cur_committed.set_end(max_prev_end); - } - // Align the end up to a page size (starts are already aligned). - jbyte* const new_end = byte_after(new_region.last()); - HeapWord* new_end_aligned = - (HeapWord*) align_size_up((uintptr_t)new_end, _page_size); - assert(new_end_aligned >= (HeapWord*) new_end, - "align up, but less"); - // Check the other regions (excludes "ind") to ensure that - // the new_end_aligned does not intrude onto the committed - // space of another region. - int ri = 0; - for (ri = ind + 1; ri < _cur_covered_regions; ri++) { - if (new_end_aligned > _committed[ri].start()) { - assert(new_end_aligned <= _committed[ri].end(), - "An earlier committed region can't cover a later committed region"); - // Any region containing the new end - // should start at or beyond the region found (ind) - // for the new end (committed regions are not expected to - // be proper subsets of other committed regions). - assert(_committed[ri].start() >= _committed[ind].start(), - "New end of committed region is inconsistent"); - new_end_aligned = _committed[ri].start(); - // new_end_aligned can be equal to the start of its - // committed region (i.e., of "ind") if a second - // region following "ind" also start at the same location - // as "ind". - assert(new_end_aligned >= _committed[ind].start(), - "New end of committed region is before start"); - debug_only(collided = true;) - // Should only collide with 1 region - break; - } - } -#ifdef ASSERT - for (++ri; ri < _cur_covered_regions; ri++) { - assert(!_committed[ri].contains(new_end_aligned), - "New end of committed region is in a second committed region"); - } -#endif - // The guard page is always committed and should not be committed over. - // "guarded" is used for assertion checking below and recalls the fact - // that the would-be end of the new committed region would have - // penetrated the guard page. - HeapWord* new_end_for_commit = new_end_aligned; - - DEBUG_ONLY(bool guarded = false;) - if (new_end_for_commit > _guard_region.start()) { - new_end_for_commit = _guard_region.start(); - DEBUG_ONLY(guarded = true;) - } - - if (new_end_for_commit > cur_committed.end()) { - // Must commit new pages. - MemRegion const new_committed = - MemRegion(cur_committed.end(), new_end_for_commit); - - assert(!new_committed.is_empty(), "Region should not be empty here"); - os::commit_memory_or_exit((char*)new_committed.start(), - new_committed.byte_size(), _page_size, - !ExecMem, "card table expansion"); - // Use new_end_aligned (as opposed to new_end_for_commit) because - // the cur_committed region may include the guard region. - } else if (new_end_aligned < cur_committed.end()) { - // Must uncommit pages. - MemRegion const uncommit_region = - committed_unique_to_self(ind, MemRegion(new_end_aligned, - cur_committed.end())); - if (!uncommit_region.is_empty()) { - // It is not safe to uncommit cards if the boundary between - // the generations is moving. A shrink can uncommit cards - // owned by generation A but being used by generation B. - if (!UseAdaptiveGCBoundary) { - if (!os::uncommit_memory((char*)uncommit_region.start(), - uncommit_region.byte_size())) { - assert(false, "Card table contraction failed"); - // The call failed so don't change the end of the - // committed region. This is better than taking the - // VM down. - new_end_aligned = _committed[ind].end(); - } - } else { - new_end_aligned = _committed[ind].end(); - } - } - } - // In any case, we can reset the end of the current committed entry. - _committed[ind].set_end(new_end_aligned); - -#ifdef ASSERT - // Check that the last card in the new region is committed according - // to the tables. - bool covered = false; - for (int cr = 0; cr < _cur_covered_regions; cr++) { - if (_committed[cr].contains(new_end - 1)) { - covered = true; - break; - } - } - assert(covered, "Card for end of new region not committed"); -#endif - - // The default of 0 is not necessarily clean cards. - jbyte* entry; - if (old_region.last() < _whole_heap.start()) { - entry = byte_for(_whole_heap.start()); - } else { - entry = byte_after(old_region.last()); - } - assert(index_for(new_region.last()) < _guard_index, - "The guard card will be overwritten"); - // This line commented out cleans the newly expanded region and - // not the aligned up expanded region. - // jbyte* const end = byte_after(new_region.last()); - jbyte* const end = (jbyte*) new_end_for_commit; - assert((end >= byte_after(new_region.last())) || collided || guarded, - "Expect to be beyond new region unless impacting another region"); - // do nothing if we resized downward. -#ifdef ASSERT - for (int ri = 0; ri < _cur_covered_regions; ri++) { - if (ri != ind) { - // The end of the new committed region should not - // be in any existing region unless it matches - // the start of the next region. - assert(!_committed[ri].contains(end) || - (_committed[ri].start() == (HeapWord*) end), - "Overlapping committed regions"); - } - } +void CardTableModRefBS::initialize() { + ModRefBarrierSet::initialize(); + // Used for ReduceInitialCardMarks (when COMPILER2 or JVMCI is used); + // otherwise remains unused. +#if defined(COMPILER2) || INCLUDE_JVMCI + _can_elide_tlab_store_barriers = can_elide_tlab_store_barriers(); + _defer_initial_card_mark = is_server_compilation_mode_vm() && ReduceInitialCardMarks && _can_elide_tlab_store_barriers + && (DeferInitialCardMark || card_mark_must_follow_store()); +#else + assert(_defer_initial_card_mark == false, "Who would set it?"); + assert(_can_elide_tlab_store_barriers == false, "Who would set it?"); #endif - if (entry < end) { - memset(entry, clean_card, pointer_delta(end, entry, sizeof(jbyte))); - } - } - // In any case, the covered size changes. - _covered[ind].set_word_size(new_region.word_size()); - - log_trace(gc, barrier)("CardTableModRefBS::resize_covered_region: "); - log_trace(gc, barrier)(" _covered[%d].start(): " INTPTR_FORMAT " _covered[%d].last(): " INTPTR_FORMAT, - ind, p2i(_covered[ind].start()), ind, p2i(_covered[ind].last())); - log_trace(gc, barrier)(" _committed[%d].start(): " INTPTR_FORMAT " _committed[%d].last(): " INTPTR_FORMAT, - ind, p2i(_committed[ind].start()), ind, p2i(_committed[ind].last())); - log_trace(gc, barrier)(" byte_for(start): " INTPTR_FORMAT " byte_for(last): " INTPTR_FORMAT, - p2i(byte_for(_covered[ind].start())), p2i(byte_for(_covered[ind].last()))); - log_trace(gc, barrier)(" addr_for(start): " INTPTR_FORMAT " addr_for(last): " INTPTR_FORMAT, - p2i(addr_for((jbyte*) _committed[ind].start())), p2i(addr_for((jbyte*) _committed[ind].last()))); - - // Touch the last card of the covered region to show that it - // is committed (or SEGV). - debug_only((void) (*byte_for(_covered[ind].last()));) - debug_only(verify_guard();) -} - -// Note that these versions are precise! The scanning code has to handle the -// fact that the write barrier may be either precise or imprecise. - -void CardTableModRefBS::write_ref_field_work(void* field, oop newVal, bool release) { - inline_write_ref_field(field, newVal, release); } +CardTableModRefBS::CardTableModRefBS( + CardTable* card_table, + const BarrierSet::FakeRtti& fake_rtti) : + ModRefBarrierSet(fake_rtti.add_tag(BarrierSet::CardTableModRef)), + _defer_initial_card_mark(false), + _can_elide_tlab_store_barriers(false), + _card_table(card_table) +{} + +CardTableModRefBS::CardTableModRefBS(CardTable* card_table) : + ModRefBarrierSet(BarrierSet::FakeRtti(BarrierSet::CardTableModRef)), + _defer_initial_card_mark(false), + _can_elide_tlab_store_barriers(false), + _card_table(card_table) +{} -void CardTableModRefBS::dirty_MemRegion(MemRegion mr) { - assert((HeapWord*)align_size_down((uintptr_t)mr.start(), HeapWordSize) == mr.start(), "Unaligned start"); - assert((HeapWord*)align_size_up ((uintptr_t)mr.end(), HeapWordSize) == mr.end(), "Unaligned end" ); - jbyte* cur = byte_for(mr.start()); - jbyte* last = byte_after(mr.last()); - while (cur < last) { - *cur = dirty_card; - cur++; - } +CardTableModRefBS::~CardTableModRefBS() { + delete _card_table; } void CardTableModRefBS::invalidate(MemRegion mr) { - assert((HeapWord*)align_size_down((uintptr_t)mr.start(), HeapWordSize) == mr.start(), "Unaligned start"); - assert((HeapWord*)align_size_up ((uintptr_t)mr.end(), HeapWordSize) == mr.end(), "Unaligned end" ); - for (int i = 0; i < _cur_covered_regions; i++) { - MemRegion mri = mr.intersection(_covered[i]); - if (!mri.is_empty()) dirty_MemRegion(mri); - } + _card_table->invalidate(mr); } -void CardTableModRefBS::clear_MemRegion(MemRegion mr) { - // Be conservative: only clean cards entirely contained within the - // region. - jbyte* cur; - if (mr.start() == _whole_heap.start()) { - cur = byte_for(mr.start()); - } else { - assert(mr.start() > _whole_heap.start(), "mr is not covered."); - cur = byte_after(mr.start() - 1); - } - jbyte* last = byte_after(mr.last()); - memset(cur, clean_card, pointer_delta(last, cur, sizeof(jbyte))); -} - -void CardTableModRefBS::clear(MemRegion mr) { - for (int i = 0; i < _cur_covered_regions; i++) { - MemRegion mri = mr.intersection(_covered[i]); - if (!mri.is_empty()) clear_MemRegion(mri); - } -} - -void CardTableModRefBS::dirty(MemRegion mr) { - jbyte* first = byte_for(mr.start()); - jbyte* last = byte_after(mr.last()); - memset(first, dirty_card, last-first); -} - -// Unlike several other card table methods, dirty_card_iterate() -// iterates over dirty cards ranges in increasing address order. -void CardTableModRefBS::dirty_card_iterate(MemRegion mr, - MemRegionClosure* cl) { - for (int i = 0; i < _cur_covered_regions; i++) { - MemRegion mri = mr.intersection(_covered[i]); - if (!mri.is_empty()) { - jbyte *cur_entry, *next_entry, *limit; - for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last()); - cur_entry <= limit; - cur_entry = next_entry) { - next_entry = cur_entry + 1; - if (*cur_entry == dirty_card) { - size_t dirty_cards; - // Accumulate maximal dirty card range, starting at cur_entry - for (dirty_cards = 1; - next_entry <= limit && *next_entry == dirty_card; - dirty_cards++, next_entry++); - MemRegion cur_cards(addr_for(cur_entry), - dirty_cards*card_size_in_words); - cl->do_MemRegion(cur_cards); - } - } - } - } -} - -MemRegion CardTableModRefBS::dirty_card_range_after_reset(MemRegion mr, - bool reset, - int reset_val) { - for (int i = 0; i < _cur_covered_regions; i++) { - MemRegion mri = mr.intersection(_covered[i]); - if (!mri.is_empty()) { - jbyte* cur_entry, *next_entry, *limit; - for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last()); - cur_entry <= limit; - cur_entry = next_entry) { - next_entry = cur_entry + 1; - if (*cur_entry == dirty_card) { - size_t dirty_cards; - // Accumulate maximal dirty card range, starting at cur_entry - for (dirty_cards = 1; - next_entry <= limit && *next_entry == dirty_card; - dirty_cards++, next_entry++); - MemRegion cur_cards(addr_for(cur_entry), - dirty_cards*card_size_in_words); - if (reset) { - for (size_t i = 0; i < dirty_cards; i++) { - cur_entry[i] = reset_val; - } - } - return cur_cards; - } - } - } - } - return MemRegion(mr.end(), mr.end()); -} - -uintx CardTableModRefBS::ct_max_alignment_constraint() { - return card_size * os::vm_page_size(); +void CardTableModRefBS::print_on(outputStream* st) const { + _card_table->print_on(st); } -void CardTableModRefBS::verify_guard() { - // For product build verification - guarantee(_byte_map[_guard_index] == last_card, - "card table guard has been modified"); -} - -void CardTableModRefBS::verify() { - verify_guard(); -} - -#ifndef PRODUCT -void CardTableModRefBS::verify_region(MemRegion mr, - jbyte val, bool val_equals) { - jbyte* start = byte_for(mr.start()); - jbyte* end = byte_for(mr.last()); - bool failures = false; - for (jbyte* curr = start; curr <= end; ++curr) { - jbyte curr_val = *curr; - bool failed = (val_equals) ? (curr_val != val) : (curr_val == val); - if (failed) { - if (!failures) { - log_error(gc, verify)("== CT verification failed: [" INTPTR_FORMAT "," INTPTR_FORMAT "]", p2i(start), p2i(end)); - log_error(gc, verify)("== %sexpecting value: %d", (val_equals) ? "" : "not ", val); - failures = true; - } - log_error(gc, verify)("== card " PTR_FORMAT " [" PTR_FORMAT "," PTR_FORMAT "], val: %d", - p2i(curr), p2i(addr_for(curr)), - p2i((HeapWord*) (((size_t) addr_for(curr)) + card_size)), - (int) curr_val); +// Helper for ReduceInitialCardMarks. For performance, +// compiled code may elide card-marks for initializing stores +// to a newly allocated object along the fast-path. We +// compensate for such elided card-marks as follows: +// (a) Generational, non-concurrent collectors, such as +// GenCollectedHeap(ParNew,DefNew,Tenured) and +// ParallelScavengeHeap(ParallelGC, ParallelOldGC) +// need the card-mark if and only if the region is +// 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, i.e. in this call. +// (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 +// slow-path allocation by this thread or just before the next scavenge or +// CMS-associated safepoint, whichever of these events happens first. +// (The implicit assumption is that the object has been fully +// initialized by this point, a fact that we assert when doing the +// card-mark.) +// (c) G1CollectedHeap(G1) uses two kinds of write barriers. When a +// G1 concurrent marking is in progress an SATB (pre-write-)barrier +// is used to remember the pre-value of any store. Initializing +// stores will not need this barrier, so we need not worry about +// compensating for the missing pre-barrier here. Turning now +// to the post-barrier, we note that G1 needs a RS update barrier +// which simply enqueues a (sequence of) dirty cards which may +// 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 both +// G1 and CMS. +// +// For any future collector, this code should be reexamined with +// that specific collector in mind, and the documentation above suitably +// extended and updated. +void CardTableModRefBS::new_deferred_store_barrier(JavaThread* thread, oop new_obj) { + // If a previous card-mark was deferred, flush it now. + flush_deferred_store_barrier(thread); + if (new_obj->is_typeArray() || _card_table->is_in_young(new_obj)) { + // Arrays of non-references don't need a post-barrier. + // The deferred_card_mark region should be empty + // following the flush above. + assert(thread->deferred_card_mark().is_empty(), "Error"); + } else { + MemRegion mr((HeapWord*)new_obj, new_obj->size()); + assert(!mr.is_empty(), "Error"); + if (_defer_initial_card_mark) { + // Defer the card mark + thread->set_deferred_card_mark(mr); + } else { + // Do the card mark + write_region(mr); } } - guarantee(!failures, "there should not have been any failures"); -} - -void CardTableModRefBS::verify_not_dirty_region(MemRegion mr) { - verify_region(mr, dirty_card, false /* val_equals */); } -void CardTableModRefBS::verify_dirty_region(MemRegion mr) { - verify_region(mr, dirty_card, true /* val_equals */); -} +void CardTableModRefBS::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(!_card_table->is_in_young(old_obj), + "Else should have been filtered in new_deferred_store_barrier()"); + assert(old_obj->is_oop(true), "Not an oop"); + assert(deferred.word_size() == (size_t)(old_obj->size()), + "Mismatch: multiple objects?"); + } + write_region(deferred); + // "Clear" the deferred_card_mark field + thread->set_deferred_card_mark(MemRegion()); + } + assert(thread->deferred_card_mark().is_empty(), "invariant"); +} + +void CardTableModRefBS::on_destroy_thread(JavaThread* thread) { + ModRefBarrierSet::on_destroy_thread(thread); + flush_deferred_store_barrier(thread); +} + +void CardTableModRefBS::make_parsable(JavaThread* thread) { + ModRefBarrierSet::make_parsable(thread); +#if defined(COMPILER2) || INCLUDE_JVMCI + // 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 (_defer_initial_card_mark) flush_deferred_store_barrier(thread); +#else + assert(!_defer_initial_card_mark, "Should be false"); + assert(thread->deferred_card_mark().is_empty(), "Should be empty"); #endif - -void CardTableModRefBS::print_on(outputStream* st) const { - st->print_cr("Card table byte_map: [" INTPTR_FORMAT "," INTPTR_FORMAT "] byte_map_base: " INTPTR_FORMAT, - p2i(_byte_map), p2i(_byte_map + _byte_map_size), p2i(byte_map_base)); } +bool CardTableModRefBS::card_mark_must_follow_store() const { + return _card_table->scanned_concurrently(); +}