1 /*
2 * Copyright (c) 2000, 2019, 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_GC_SHARED_CARDTABLEBARRIERSET_HPP
26 #define SHARE_GC_SHARED_CARDTABLEBARRIERSET_HPP
27
28 #include "gc/shared/cardTable.hpp"
29 #include "gc/shared/modRefBarrierSet.hpp"
30 #include "utilities/align.hpp"
31
32 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
33 // enumerate ref fields that have been modified (since the last
34 // enumeration.)
35
36 // As it currently stands, this barrier is *imprecise*: when a ref field in
37 // an object "o" is modified, the card table entry for the card containing
38 // the head of "o" is dirtied, not necessarily the card containing the
39 // modified field itself. For object arrays, however, the barrier *is*
40 // precise; only the card containing the modified element is dirtied.
41 // Closures used to scan dirty cards should take these
42 // considerations into account.
43
44 class CardTableBarrierSet: public ModRefBarrierSet {
45 // Some classes get to look at some private stuff.
46 friend class VMStructs;
47
48 protected:
49 typedef CardTable::CardValue CardValue;
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 virtual ~CardTableBarrierSet();
64
65 CardTable* card_table() const { return _card_table; }
66
67 void initialize();
68
69 void write_region(JavaThread* thread, MemRegion mr) {
70 write_region(mr);
71 }
72
73 public:
74 // Record a reference update. Note that these versions are precise!
75 // The scanning code has to handle the fact that the write barrier may be
76 // either precise or imprecise. We make non-virtual inline variants of
77 // these functions here for performance.
78 template <DecoratorSet decorators, typename T>
79 void write_ref_field_post(T* field);
80
81 virtual void write_region(MemRegion mr);
82
83 // ReduceInitialCardMarks
84 void initialize_deferred_card_mark_barriers();
85
86 // If the CollectedHeap was asked to defer a store barrier above,
87 // this informs it to flush such a deferred store barrier to the
88 // remembered set.
89 void flush_deferred_card_mark_barrier(JavaThread* thread);
90
91 // If a compiler is eliding store barriers for TLAB-allocated objects,
92 // we will be informed of a slow-path allocation by a call
93 // to on_slowpath_allocation_exit() below. Such a call precedes the
94 // initialization of the object itself, and no post-store-barriers will
95 // be issued. Some heap types require that the barrier strictly follows
96 // the initializing stores. (This is currently implemented by deferring the
97 // barrier until the next slow-path allocation or gc-related safepoint.)
98 // This interface answers whether a particular barrier type needs the card
99 // mark to be thus strictly sequenced after the stores.
100 virtual bool card_mark_must_follow_store() const;
101
102 virtual void on_slowpath_allocation_exit(JavaThread* thread, oop new_obj);
103 virtual void on_thread_detach(Thread* thread);
104
105 virtual void make_parsable(JavaThread* thread) { flush_deferred_card_mark_barrier(thread); }
106
107 virtual void print_on(outputStream* st) const;
108
109 // The AOT code cache manager needs to know the current card shift
110 // and, for some barrier sets, the region grain size shift
111 uint card_shift() const { return _card_table->card_shift(); }
112 virtual uint grain_shift() { return 0; }
113
114 template <DecoratorSet decorators, typename BarrierSetT = CardTableBarrierSet>
115 class AccessBarrier: public ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT> {};
116 };
117
118 template<>
119 struct BarrierSet::GetName<CardTableBarrierSet> {
120 static const BarrierSet::Name value = BarrierSet::CardTableBarrierSet;
121 };
122
123 template<>
124 struct BarrierSet::GetType<BarrierSet::CardTableBarrierSet> {
125 typedef ::CardTableBarrierSet type;
126 };
127
128 #endif // SHARE_GC_SHARED_CARDTABLEBARRIERSET_HPP