19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25 #include "gc/shared/cardTableBarrierSetAssembler.hpp"
26 #include "gc/shared/cardTableBarrierSet.inline.hpp"
27 #include "gc/shared/collectedHeap.hpp"
28 #include "gc/shared/space.inline.hpp"
29 #include "logging/log.hpp"
30 #include "memory/virtualspace.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "runtime/thread.hpp"
33 #include "services/memTracker.hpp"
34 #include "utilities/align.hpp"
35 #include "utilities/macros.hpp"
36 #ifdef COMPILER1
37 #include "gc/shared/c1/cardTableBarrierSetC1.hpp"
38 #endif
39
40 class CardTableBarrierSetC1;
41
42 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
43 // enumerate ref fields that have been modified (since the last
44 // enumeration.)
45
46 CardTableBarrierSet::CardTableBarrierSet(BarrierSetAssembler* barrier_set_assembler,
47 BarrierSetC1* barrier_set_c1,
48 CardTable* card_table,
49 const BarrierSet::FakeRtti& fake_rtti) :
50 ModRefBarrierSet(barrier_set_assembler,
51 barrier_set_c1,
52 fake_rtti.add_tag(BarrierSet::CardTableBarrierSet)),
53 _defer_initial_card_mark(false),
54 _card_table(card_table)
55 {}
56
57 CardTableBarrierSet::CardTableBarrierSet(CardTable* card_table) :
58 ModRefBarrierSet(make_barrier_set_assembler<CardTableBarrierSetAssembler>(),
59 make_barrier_set_c1<CardTableBarrierSetC1>(),
60 BarrierSet::FakeRtti(BarrierSet::CardTableBarrierSet)),
61 _defer_initial_card_mark(false),
62 _card_table(card_table)
63 {}
64
65 void CardTableBarrierSet::initialize() {
66 initialize_deferred_card_mark_barriers();
67 }
68
69 CardTableBarrierSet::~CardTableBarrierSet() {
70 delete _card_table;
71 }
72
73 void CardTableBarrierSet::write_ref_array_work(MemRegion mr) {
74 _card_table->dirty_MemRegion(mr);
75 }
76
77 void CardTableBarrierSet::invalidate(MemRegion mr) {
78 _card_table->invalidate(mr);
|
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25 #include "gc/shared/cardTableBarrierSetAssembler.hpp"
26 #include "gc/shared/cardTableBarrierSet.inline.hpp"
27 #include "gc/shared/collectedHeap.hpp"
28 #include "gc/shared/space.inline.hpp"
29 #include "logging/log.hpp"
30 #include "memory/virtualspace.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "runtime/thread.hpp"
33 #include "services/memTracker.hpp"
34 #include "utilities/align.hpp"
35 #include "utilities/macros.hpp"
36 #ifdef COMPILER1
37 #include "gc/shared/c1/cardTableBarrierSetC1.hpp"
38 #endif
39 #ifdef COMPILER2
40 #include "gc/shared/c2/cardTableBarrierSetC2.hpp"
41 #endif
42
43 class CardTableBarrierSetC1;
44 class CardTableBarrierSetC2;
45
46 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
47 // enumerate ref fields that have been modified (since the last
48 // enumeration.)
49
50 CardTableBarrierSet::CardTableBarrierSet(BarrierSetAssembler* barrier_set_assembler,
51 BarrierSetC1* barrier_set_c1,
52 BarrierSetC2* barrier_set_c2,
53 CardTable* card_table,
54 const BarrierSet::FakeRtti& fake_rtti) :
55 ModRefBarrierSet(barrier_set_assembler,
56 barrier_set_c1,
57 barrier_set_c2,
58 fake_rtti.add_tag(BarrierSet::CardTableBarrierSet)),
59 _defer_initial_card_mark(false),
60 _card_table(card_table)
61 {}
62
63 CardTableBarrierSet::CardTableBarrierSet(CardTable* card_table) :
64 ModRefBarrierSet(make_barrier_set_assembler<CardTableBarrierSetAssembler>(),
65 make_barrier_set_c1<CardTableBarrierSetC1>(),
66 make_barrier_set_c2<CardTableBarrierSetC2>(),
67 BarrierSet::FakeRtti(BarrierSet::CardTableBarrierSet)),
68 _defer_initial_card_mark(false),
69 _card_table(card_table)
70 {}
71
72 void CardTableBarrierSet::initialize() {
73 initialize_deferred_card_mark_barriers();
74 }
75
76 CardTableBarrierSet::~CardTableBarrierSet() {
77 delete _card_table;
78 }
79
80 void CardTableBarrierSet::write_ref_array_work(MemRegion mr) {
81 _card_table->dirty_MemRegion(mr);
82 }
83
84 void CardTableBarrierSet::invalidate(MemRegion mr) {
85 _card_table->invalidate(mr);
|
137 // following the flush above.
138 assert(thread->deferred_card_mark().is_empty(), "Error");
139 } else {
140 MemRegion mr((HeapWord*)new_obj, new_obj->size());
141 assert(!mr.is_empty(), "Error");
142 if (_defer_initial_card_mark) {
143 // Defer the card mark
144 thread->set_deferred_card_mark(mr);
145 } else {
146 // Do the card mark
147 invalidate(mr);
148 }
149 }
150 #endif // COMPILER2 || JVMCI
151 }
152
153 void CardTableBarrierSet::initialize_deferred_card_mark_barriers() {
154 // Used for ReduceInitialCardMarks (when COMPILER2 or JVMCI is used);
155 // otherwise remains unused.
156 #if defined(COMPILER2) || INCLUDE_JVMCI
157 _defer_initial_card_mark = is_server_compilation_mode_vm() && ReduceInitialCardMarks && can_elide_tlab_store_barriers()
158 && (DeferInitialCardMark || card_mark_must_follow_store());
159 #else
160 assert(_defer_initial_card_mark == false, "Who would set it?");
161 #endif
162 }
163
164 void CardTableBarrierSet::flush_deferred_card_mark_barrier(JavaThread* thread) {
165 #if defined(COMPILER2) || INCLUDE_JVMCI
166 MemRegion deferred = thread->deferred_card_mark();
167 if (!deferred.is_empty()) {
168 assert(_defer_initial_card_mark, "Otherwise should be empty");
169 {
170 // Verify that the storage points to a parsable object in heap
171 DEBUG_ONLY(oop old_obj = oop(deferred.start());)
172 assert(!_card_table->is_in_young(old_obj),
173 "Else should have been filtered in on_slowpath_allocation_exit()");
174 assert(oopDesc::is_oop(old_obj, true), "Not an oop");
175 assert(deferred.word_size() == (size_t)(old_obj->size()),
176 "Mismatch: multiple objects?");
|
144 // following the flush above.
145 assert(thread->deferred_card_mark().is_empty(), "Error");
146 } else {
147 MemRegion mr((HeapWord*)new_obj, new_obj->size());
148 assert(!mr.is_empty(), "Error");
149 if (_defer_initial_card_mark) {
150 // Defer the card mark
151 thread->set_deferred_card_mark(mr);
152 } else {
153 // Do the card mark
154 invalidate(mr);
155 }
156 }
157 #endif // COMPILER2 || JVMCI
158 }
159
160 void CardTableBarrierSet::initialize_deferred_card_mark_barriers() {
161 // Used for ReduceInitialCardMarks (when COMPILER2 or JVMCI is used);
162 // otherwise remains unused.
163 #if defined(COMPILER2) || INCLUDE_JVMCI
164 _defer_initial_card_mark = is_server_compilation_mode_vm() && ReduceInitialCardMarks
165 && (DeferInitialCardMark || card_mark_must_follow_store());
166 #else
167 assert(_defer_initial_card_mark == false, "Who would set it?");
168 #endif
169 }
170
171 void CardTableBarrierSet::flush_deferred_card_mark_barrier(JavaThread* thread) {
172 #if defined(COMPILER2) || INCLUDE_JVMCI
173 MemRegion deferred = thread->deferred_card_mark();
174 if (!deferred.is_empty()) {
175 assert(_defer_initial_card_mark, "Otherwise should be empty");
176 {
177 // Verify that the storage points to a parsable object in heap
178 DEBUG_ONLY(oop old_obj = oop(deferred.start());)
179 assert(!_card_table->is_in_young(old_obj),
180 "Else should have been filtered in on_slowpath_allocation_exit()");
181 assert(oopDesc::is_oop(old_obj, true), "Not an oop");
182 assert(deferred.word_size() == (size_t)(old_obj->size()),
183 "Mismatch: multiple objects?");
|