Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1ParScanThreadState.hpp @ 20304:a22acf6d7598
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Mon, 21 Jul 2014 10:00:31 +0200 |
| parents | a2328cbebb23 |
| children | 227a9e5e4b4a |
| rev | line source |
|---|---|
| 20223 | 1 /* |
| 2 * Copyright (c) 2014, 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_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP | |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/dirtyCardQueue.hpp" | |
| 29 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp" | |
| 30 #include "gc_implementation/g1/g1CollectedHeap.hpp" | |
| 31 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
| 32 #include "gc_implementation/g1/g1OopClosures.hpp" | |
| 33 #include "gc_implementation/g1/g1RemSet.hpp" | |
| 34 #include "gc_implementation/shared/ageTable.hpp" | |
| 35 #include "memory/allocation.hpp" | |
| 36 #include "oops/oop.hpp" | |
| 37 | |
| 38 class HeapRegion; | |
| 39 class outputStream; | |
| 40 | |
| 41 class G1ParScanThreadState : public StackObj { | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
42 private: |
| 20223 | 43 G1CollectedHeap* _g1h; |
| 44 RefToScanQueue* _refs; | |
| 45 DirtyCardQueue _dcq; | |
| 46 G1SATBCardTableModRefBS* _ct_bs; | |
| 47 G1RemSet* _g1_rem; | |
| 48 | |
| 49 G1ParGCAllocBuffer _surviving_alloc_buffer; | |
| 50 G1ParGCAllocBuffer _tenured_alloc_buffer; | |
| 51 G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount]; | |
| 52 ageTable _age_table; | |
| 53 | |
| 54 G1ParScanClosure _scanner; | |
| 55 | |
| 56 size_t _alloc_buffer_waste; | |
| 57 size_t _undo_waste; | |
| 58 | |
| 59 OopsInHeapRegionClosure* _evac_failure_cl; | |
| 60 | |
| 61 int _hash_seed; | |
| 62 uint _queue_num; | |
| 63 | |
| 64 size_t _term_attempts; | |
| 65 | |
| 66 double _start; | |
| 67 double _start_strong_roots; | |
| 68 double _strong_roots_time; | |
| 69 double _start_term; | |
| 70 double _term_time; | |
| 71 | |
| 72 // Map from young-age-index (0 == not young, 1 is youngest) to | |
| 73 // surviving words. base is what we get back from the malloc call | |
| 74 size_t* _surviving_young_words_base; | |
| 75 // this points into the array, as we use the first few entries for padding | |
| 76 size_t* _surviving_young_words; | |
| 77 | |
| 78 #define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t)) | |
| 79 | |
| 80 void add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; } | |
| 81 | |
| 82 void add_to_undo_waste(size_t waste) { _undo_waste += waste; } | |
| 83 | |
| 84 DirtyCardQueue& dirty_card_queue() { return _dcq; } | |
| 85 G1SATBCardTableModRefBS* ctbs() { return _ct_bs; } | |
| 86 | |
| 87 template <class T> inline void immediate_rs_update(HeapRegion* from, T* p, int tid); | |
| 88 | |
| 89 template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) { | |
| 90 // If the new value of the field points to the same region or | |
| 91 // is the to-space, we don't need to include it in the Rset updates. | |
| 92 if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) { | |
| 93 size_t card_index = ctbs()->index_for(p); | |
| 94 // If the card hasn't been added to the buffer, do it. | |
| 95 if (ctbs()->mark_card_deferred(card_index)) { | |
| 96 dirty_card_queue().enqueue((jbyte*)ctbs()->byte_for_index(card_index)); | |
| 97 } | |
| 98 } | |
| 99 } | |
| 100 | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
101 public: |
| 20223 | 102 G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp); |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
103 ~G1ParScanThreadState(); |
| 20223 | 104 |
| 105 ageTable* age_table() { return &_age_table; } | |
| 106 | |
| 107 G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) { | |
| 108 return _alloc_buffers[purpose]; | |
| 109 } | |
| 110 | |
| 111 size_t alloc_buffer_waste() const { return _alloc_buffer_waste; } | |
| 112 size_t undo_waste() const { return _undo_waste; } | |
| 113 | |
| 114 #ifdef ASSERT | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
115 bool queue_is_empty() const { return _refs->is_empty(); } |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
116 |
| 20223 | 117 bool verify_ref(narrowOop* ref) const; |
| 118 bool verify_ref(oop* ref) const; | |
| 119 bool verify_task(StarTask ref) const; | |
| 120 #endif // ASSERT | |
| 121 | |
| 122 template <class T> void push_on_queue(T* ref) { | |
| 123 assert(verify_ref(ref), "sanity"); | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
124 _refs->push(ref); |
| 20223 | 125 } |
| 126 | |
| 127 template <class T> inline void update_rs(HeapRegion* from, T* p, int tid); | |
| 128 | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
129 private: |
| 20223 | 130 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
131 inline HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz); |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
132 inline HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz); |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
133 inline void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz); |
| 20223 | 134 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
135 public: |
| 20223 | 136 |
| 137 void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) { | |
| 138 _evac_failure_cl = evac_failure_cl; | |
| 139 } | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
140 |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
141 OopsInHeapRegionClosure* evac_failure_closure() { return _evac_failure_cl; } |
| 20223 | 142 |
| 143 int* hash_seed() { return &_hash_seed; } | |
| 144 uint queue_num() { return _queue_num; } | |
| 145 | |
| 146 size_t term_attempts() const { return _term_attempts; } | |
| 147 void note_term_attempt() { _term_attempts++; } | |
| 148 | |
| 149 void start_strong_roots() { | |
| 150 _start_strong_roots = os::elapsedTime(); | |
| 151 } | |
| 152 void end_strong_roots() { | |
| 153 _strong_roots_time += (os::elapsedTime() - _start_strong_roots); | |
| 154 } | |
| 155 double strong_roots_time() const { return _strong_roots_time; } | |
| 156 | |
| 157 void start_term_time() { | |
| 158 note_term_attempt(); | |
| 159 _start_term = os::elapsedTime(); | |
| 160 } | |
| 161 void end_term_time() { | |
| 162 _term_time += (os::elapsedTime() - _start_term); | |
| 163 } | |
| 164 double term_time() const { return _term_time; } | |
| 165 | |
| 166 double elapsed_time() const { | |
| 167 return os::elapsedTime() - _start; | |
| 168 } | |
| 169 | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
170 static void print_termination_stats_hdr(outputStream* const st = gclog_or_tty); |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
171 void print_termination_stats(int i, outputStream* const st = gclog_or_tty) const; |
| 20223 | 172 |
| 173 size_t* surviving_young_words() { | |
| 174 // We add on to hide entry 0 which accumulates surviving words for | |
| 175 // age -1 regions (i.e. non-young ones) | |
| 176 return _surviving_young_words; | |
| 177 } | |
| 178 | |
| 179 private: | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
180 void retire_alloc_buffers(); |
| 20223 | 181 |
| 182 #define G1_PARTIAL_ARRAY_MASK 0x2 | |
| 183 | |
| 184 inline bool has_partial_array_mask(oop* ref) const { | |
| 185 return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK; | |
| 186 } | |
| 187 | |
| 188 // We never encode partial array oops as narrowOop*, so return false immediately. | |
| 189 // This allows the compiler to create optimized code when popping references from | |
| 190 // the work queue. | |
| 191 inline bool has_partial_array_mask(narrowOop* ref) const { | |
| 192 assert(((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) != G1_PARTIAL_ARRAY_MASK, "Partial array oop reference encoded as narrowOop*"); | |
| 193 return false; | |
| 194 } | |
| 195 | |
| 196 // Only implement set_partial_array_mask() for regular oops, not for narrowOops. | |
| 197 // We always encode partial arrays as regular oop, to allow the | |
| 198 // specialization for has_partial_array_mask() for narrowOops above. | |
| 199 // This means that unintentional use of this method with narrowOops are caught | |
| 200 // by the compiler. | |
| 201 inline oop* set_partial_array_mask(oop obj) const { | |
| 202 assert(((uintptr_t)(void *)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!"); | |
| 203 return (oop*) ((uintptr_t)(void *)obj | G1_PARTIAL_ARRAY_MASK); | |
| 204 } | |
| 205 | |
| 206 inline oop clear_partial_array_mask(oop* ref) const { | |
| 207 return cast_to_oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK); | |
| 208 } | |
| 209 | |
| 210 inline void do_oop_partial_array(oop* p); | |
| 211 | |
| 212 // This method is applied to the fields of the objects that have just been copied. | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
213 template <class T> inline void do_oop_evac(T* p, HeapRegion* from); |
| 20223 | 214 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
215 template <class T> inline void deal_with_reference(T* ref_to_scan); |
| 20223 | 216 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
217 inline void dispatch_reference(StarTask ref); |
|
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
218 public: |
| 20223 | 219 |
| 220 oop copy_to_survivor_space(oop const obj); | |
| 221 | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
222 void trim_queue(); |
| 20223 | 223 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
224 inline void steal_and_trim_queue(RefToScanQueueSet *task_queues); |
| 20223 | 225 }; |
| 226 | |
| 227 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP |