1 /* 2 * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved. 3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHBARRIERSET_HPP 27 #define SHARE_GC_SHENANDOAH_SHENANDOAHBARRIERSET_HPP 28 29 #include "gc/shared/barrierSet.hpp" 30 #include "gc/shared/bufferNode.hpp" 31 #include "gc/shenandoah/shenandoahSATBMarkQueueSet.hpp" 32 33 class ShenandoahHeap; 34 class ShenandoahBarrierSetAssembler; 35 class ShenandoahCardTable; 36 37 class ShenandoahBarrierSet: public BarrierSet { 38 private: 39 ShenandoahHeap* const _heap; 40 ShenandoahCardTable* _card_table; 41 BufferNode::Allocator _satb_mark_queue_buffer_allocator; 42 ShenandoahSATBMarkQueueSet _satb_mark_queue_set; 43 44 public: 45 ShenandoahBarrierSet(ShenandoahHeap* heap, MemRegion heap_region); 46 47 static ShenandoahBarrierSetAssembler* assembler(); 48 49 inline static ShenandoahBarrierSet* barrier_set() { 50 return barrier_set_cast<ShenandoahBarrierSet>(BarrierSet::barrier_set()); 51 } 52 53 inline ShenandoahCardTable* card_table() { 54 return _card_table; 55 } 56 57 static ShenandoahSATBMarkQueueSet& satb_mark_queue_set() { 58 return barrier_set()->_satb_mark_queue_set; 59 } 60 61 static bool need_load_reference_barrier(DecoratorSet decorators, BasicType type); 62 static bool need_keep_alive_barrier(DecoratorSet decorators, BasicType type); 63 64 static bool is_strong_access(DecoratorSet decorators) { 65 return (decorators & (ON_WEAK_OOP_REF | ON_PHANTOM_OOP_REF)) == 0; 66 } 67 68 static bool is_weak_access(DecoratorSet decorators) { 69 return (decorators & ON_WEAK_OOP_REF) != 0; 70 } 71 72 static bool is_phantom_access(DecoratorSet decorators) { 73 return (decorators & ON_PHANTOM_OOP_REF) != 0; 74 } 75 76 static bool is_native_access(DecoratorSet decorators) { 77 return (decorators & IN_NATIVE) != 0; 78 } 79 80 void print_on(outputStream* st) const; 81 82 template <class T> 83 inline void arraycopy_barrier(T* src, T* dst, size_t count); 84 inline void clone_barrier(oop src); 85 void clone_barrier_runtime(oop src); 86 87 virtual void on_thread_create(Thread* thread); 88 virtual void on_thread_destroy(Thread* thread); 89 virtual void on_thread_attach(Thread* thread); 90 virtual void on_thread_detach(Thread* thread); 91 92 static inline oop resolve_forwarded_not_null(oop p); 93 static inline oop resolve_forwarded_not_null_mutator(oop p); 94 static inline oop resolve_forwarded(oop p); 95 96 template <DecoratorSet decorators, typename T> 97 inline void satb_barrier(T* field); 98 inline void satb_enqueue(oop value); 99 100 inline void keep_alive_if_weak(DecoratorSet decorators, oop value); 101 102 inline void enqueue(oop obj); 103 104 inline oop load_reference_barrier(oop obj); 105 106 template <class T> 107 inline oop load_reference_barrier_mutator(oop obj, T* load_addr); 108 109 template <class T> 110 inline oop load_reference_barrier(DecoratorSet decorators, oop obj, T* load_addr); 111 112 template <typename T> 113 inline oop oop_load(DecoratorSet decorators, T* addr); 114 115 template <typename T> 116 inline oop oop_cmpxchg(DecoratorSet decorators, T* addr, oop compare_value, oop new_value); 117 118 template <typename T> 119 inline oop oop_xchg(DecoratorSet decorators, T* addr, oop new_value); 120 121 template <DecoratorSet decorators, typename T> 122 void write_ref_field_post(T* field); 123 124 void write_ref_array(HeapWord* start, size_t count); 125 126 private: 127 template <class T> 128 inline void arraycopy_marking(T* src, T* dst, size_t count, bool is_old_marking); 129 template <class T> 130 inline void arraycopy_evacuation(T* src, size_t count); 131 template <class T> 132 inline void arraycopy_update(T* src, size_t count); 133 134 inline void clone_evacuation(oop src); 135 inline void clone_update(oop src); 136 137 template <class T, bool HAS_FWD, bool EVAC, bool ENQUEUE> 138 inline void arraycopy_work(T* src, size_t count); 139 140 inline bool need_bulk_update(HeapWord* dst); 141 public: 142 // Callbacks for runtime accesses. 143 template <DecoratorSet decorators, typename BarrierSetT = ShenandoahBarrierSet> 144 class AccessBarrier: public BarrierSet::AccessBarrier<decorators, BarrierSetT> { 145 typedef BarrierSet::AccessBarrier<decorators, BarrierSetT> Raw; 146 147 private: 148 template <typename T> 149 static void oop_store_common(T* addr, oop value); 150 151 public: 152 // Heap oop accesses. These accessors get resolved when 153 // IN_HEAP is set (e.g. when using the HeapAccess API), it is 154 // an oop_* overload, and the barrier strength is AS_NORMAL. 155 template <typename T> 156 static oop oop_load_in_heap(T* addr); 157 static oop oop_load_in_heap_at(oop base, ptrdiff_t offset); 158 159 template <typename T> 160 static void oop_store_in_heap(T* addr, oop value); 161 static void oop_store_in_heap_at(oop base, ptrdiff_t offset, oop value); 162 163 template <typename T> 164 static oop oop_atomic_cmpxchg_in_heap(T* addr, oop compare_value, oop new_value); 165 static oop oop_atomic_cmpxchg_in_heap_at(oop base, ptrdiff_t offset, oop compare_value, oop new_value); 166 167 template <typename T> 168 static oop oop_atomic_xchg_in_heap(T* addr, oop new_value); 169 static oop oop_atomic_xchg_in_heap_at(oop base, ptrdiff_t offset, oop new_value); 170 171 template <typename T> 172 static bool oop_arraycopy_in_heap(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 173 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 174 size_t length); 175 176 // Clone barrier support 177 static void clone_in_heap(oop src, oop dst, size_t size); 178 179 // Support for concurrent roots evacuation, updating and weak roots clearing 180 template <typename T> 181 static oop oop_load_not_in_heap(T* addr); 182 183 // Support for concurrent roots marking 184 template <typename T> 185 static void oop_store_not_in_heap(T* addr, oop value); 186 187 template <typename T> 188 static oop oop_atomic_cmpxchg_not_in_heap(T* addr, oop compare_value, oop new_value); 189 190 template <typename T> 191 static oop oop_atomic_xchg_not_in_heap(T* addr, oop new_value); 192 }; 193 194 }; 195 196 template<> 197 struct BarrierSet::GetName<ShenandoahBarrierSet> { 198 static const BarrierSet::Name value = BarrierSet::ShenandoahBarrierSet; 199 }; 200 201 template<> 202 struct BarrierSet::GetType<BarrierSet::ShenandoahBarrierSet> { 203 typedef ::ShenandoahBarrierSet type; 204 }; 205 206 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHBARRIERSET_HPP --- EOF ---