1 /* 2 * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_GC_SHARED_CARDTABLEBARRIERSET_HPP 26 #define SHARE_VM_GC_SHARED_CARDTABLEBARRIERSET_HPP 27 28 #include "gc/shared/modRefBarrierSet.hpp" 29 #include "utilities/align.hpp" 30 31 class CardTable; 32 33 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and 34 // enumerate ref fields that have been modified (since the last 35 // enumeration.) 36 37 // As it currently stands, this barrier is *imprecise*: when a ref field in 38 // an object "o" is modified, the card table entry for the card containing 39 // the head of "o" is dirtied, not necessarily the card containing the 40 // modified field itself. For object arrays, however, the barrier *is* 41 // precise; only the card containing the modified element is dirtied. 42 // Closures used to scan dirty cards should take these 43 // considerations into account. 44 45 class CardTableBarrierSet: public ModRefBarrierSet { 46 // Some classes get to look at some private stuff. 47 friend class VMStructs; 48 protected: 49 50 // Used in support of ReduceInitialCardMarks; only consulted if COMPILER2 51 // or INCLUDE_JVMCI is being used 52 bool _defer_initial_card_mark; 53 CardTable* _card_table; 54 55 CardTableBarrierSet(BarrierSetAssembler* barrier_set_assembler, 56 BarrierSetC1* barrier_set_c1, 57 BarrierSetC2* barrier_set_c2, 58 CardTable* card_table, 59 const BarrierSet::FakeRtti& fake_rtti); 60 61 public: 62 CardTableBarrierSet(CardTable* card_table); 63 ~CardTableBarrierSet(); 64 card_table() const65 CardTable* card_table() const { return _card_table; } 66 67 virtual void initialize(); 68 write_region(MemRegion mr)69 void write_region(MemRegion mr) { 70 invalidate(mr); 71 } 72 73 void write_ref_array_work(MemRegion mr); 74 75 public: 76 // Record a reference update. Note that these versions are precise! 77 // The scanning code has to handle the fact that the write barrier may be 78 // either precise or imprecise. We make non-virtual inline variants of 79 // these functions here for performance. 80 template <DecoratorSet decorators, typename T> 81 void write_ref_field_post(T* field, oop newVal); 82 83 virtual void invalidate(MemRegion mr); 84 85 // ReduceInitialCardMarks 86 void initialize_deferred_card_mark_barriers(); 87 88 // If the CollectedHeap was asked to defer a store barrier above, 89 // this informs it to flush such a deferred store barrier to the 90 // remembered set. 91 void flush_deferred_card_mark_barrier(JavaThread* thread); 92 93 // If a compiler is eliding store barriers for TLAB-allocated objects, 94 // we will be informed of a slow-path allocation by a call 95 // to on_slowpath_allocation_exit() below. Such a call precedes the 96 // initialization of the object itself, and no post-store-barriers will 97 // be issued. Some heap types require that the barrier strictly follows 98 // the initializing stores. (This is currently implemented by deferring the 99 // barrier until the next slow-path allocation or gc-related safepoint.) 100 // This interface answers whether a particular barrier type needs the card 101 // mark to be thus strictly sequenced after the stores. 102 virtual bool card_mark_must_follow_store() const; 103 104 virtual void on_slowpath_allocation_exit(JavaThread* thread, oop new_obj); 105 virtual void on_thread_detach(JavaThread* thread); 106 make_parsable(JavaThread * thread)107 virtual void make_parsable(JavaThread* thread) { flush_deferred_card_mark_barrier(thread); } 108 109 virtual void print_on(outputStream* st) const; 110 111 template <DecoratorSet decorators, typename BarrierSetT = CardTableBarrierSet> 112 class AccessBarrier: public ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT> {}; 113 }; 114 115 template<> 116 struct BarrierSet::GetName<CardTableBarrierSet> { 117 static const BarrierSet::Name value = BarrierSet::CardTableBarrierSet; 118 }; 119 120 template<> 121 struct BarrierSet::GetType<BarrierSet::CardTableBarrierSet> { 122 typedef ::CardTableBarrierSet type; 123 }; 124 125 #endif // SHARE_VM_GC_SHARED_CARDTABLEBARRIERSET_HPP 126