Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | d2a62e0f25eb |
| children | f2110083203d |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 4909 | 2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP | |
| 27 | |
| 28 #include "gc_implementation/parallelScavenge/psPromotionLAB.hpp" | |
| 29 #include "memory/allocation.hpp" | |
| 30 #include "utilities/taskqueue.hpp" | |
| 31 | |
| 0 | 32 // |
| 33 // psPromotionManager is used by a single thread to manage object survival | |
| 34 // during a scavenge. The promotion manager contains thread local data only. | |
| 35 // | |
| 36 // NOTE! Be carefull when allocating the stacks on cheap. If you are going | |
| 37 // to use a promotion manager in more than one thread, the stacks MUST be | |
| 38 // on cheap. This can lead to memory leaks, though, as they are not auto | |
| 39 // deallocated. | |
| 40 // | |
| 41 // FIX ME FIX ME Add a destructor, and don't rely on the user to drain/flush/deallocate! | |
| 42 // | |
| 43 | |
| 44 // Move to some global location | |
| 45 #define HAS_BEEN_MOVED 0x1501d01d | |
| 46 // End move to some global location | |
| 47 | |
| 48 class MutableSpace; | |
| 49 class PSOldGen; | |
| 50 class ParCompactionManager; | |
| 51 | |
| 6197 | 52 class PSPromotionManager : public CHeapObj<mtGC> { |
| 0 | 53 friend class PSScavenge; |
| 54 friend class PSRefProcTaskExecutor; | |
| 55 private: | |
| 56 static PSPromotionManager** _manager_array; | |
| 57 static OopStarTaskQueueSet* _stack_array_depth; | |
| 58 static PSOldGen* _old_gen; | |
| 59 static MutableSpace* _young_space; | |
| 60 | |
| 1665 | 61 #if TASKQUEUE_STATS |
| 62 size_t _masked_pushes; | |
| 63 size_t _masked_steals; | |
| 64 size_t _arrays_chunked; | |
| 65 size_t _array_chunks_processed; | |
| 0 | 66 |
| 1665 | 67 void print_taskqueue_stats(uint i) const; |
| 68 void print_local_stats(uint i) const; | |
| 69 static void print_stats(); | |
| 0 | 70 |
| 1665 | 71 void reset_stats(); |
| 72 #endif // TASKQUEUE_STATS | |
| 0 | 73 |
| 74 PSYoungPromotionLAB _young_lab; | |
| 75 PSOldPromotionLAB _old_lab; | |
| 76 bool _young_gen_is_full; | |
| 77 bool _old_gen_is_full; | |
| 78 | |
| 79 OopStarTaskQueue _claimed_stack_depth; | |
| 6197 | 80 OverflowTaskQueue<oop, mtGC> _claimed_stack_breadth; |
| 0 | 81 |
| 82 bool _totally_drain; | |
| 83 uint _target_stack_size; | |
| 84 | |
| 85 uint _array_chunk_size; | |
| 86 uint _min_array_size_for_chunking; | |
| 87 | |
| 88 // Accessors | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
89 static PSOldGen* old_gen() { return _old_gen; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
90 static MutableSpace* young_space() { return _young_space; } |
| 0 | 91 |
| 92 inline static PSPromotionManager* manager_array(int index); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
93 template <class T> inline void claim_or_forward_internal_depth(T* p); |
| 0 | 94 |
| 95 // On the task queues we push reference locations as well as | |
| 96 // partially-scanned arrays (in the latter case, we push an oop to | |
| 97 // the from-space image of the array and the length on the | |
| 98 // from-space image indicates how many entries on the array we still | |
| 99 // need to scan; this is basically how ParNew does partial array | |
| 100 // scanning too). To be able to distinguish between reference | |
| 101 // locations and partially-scanned array oops we simply mask the | |
| 102 // latter oops with 0x01. The next three methods do the masking, | |
| 103 // unmasking, and checking whether the oop is masked or not. Notice | |
| 104 // that the signature of the mask and unmask methods looks a bit | |
| 105 // strange, as they accept and return different types (oop and | |
| 106 // oop*). This is because of the difference in types between what | |
| 107 // the task queue holds (oop*) and oops to partially-scanned arrays | |
| 108 // (oop). We do all the necessary casting in the mask / unmask | |
| 109 // methods to avoid sprinkling the rest of the code with more casts. | |
| 110 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
111 // These are added to the taskqueue so PS_CHUNKED_ARRAY_OOP_MASK (or any |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
112 // future masks) can't conflict with COMPRESSED_OOP_MASK |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
113 #define PS_CHUNKED_ARRAY_OOP_MASK 0x2 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
114 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
115 bool is_oop_masked(StarTask p) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
116 // If something is marked chunked it's always treated like wide oop* |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
117 return (((intptr_t)(oop*)p) & PS_CHUNKED_ARRAY_OOP_MASK) == |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
118 PS_CHUNKED_ARRAY_OOP_MASK; |
| 0 | 119 } |
| 120 | |
| 121 oop* mask_chunked_array_oop(oop obj) { | |
| 122 assert(!is_oop_masked((oop*) obj), "invariant"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
123 oop* ret = (oop*) ((uintptr_t)obj | PS_CHUNKED_ARRAY_OOP_MASK); |
| 0 | 124 assert(is_oop_masked(ret), "invariant"); |
| 125 return ret; | |
| 126 } | |
| 127 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
128 oop unmask_chunked_array_oop(StarTask p) { |
| 0 | 129 assert(is_oop_masked(p), "invariant"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
130 assert(!p.is_narrow(), "chunked array oops cannot be narrow"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
131 oop *chunk = (oop*)p; // cast p to oop (uses conversion operator) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
132 oop ret = oop((oop*)((uintptr_t)chunk & ~PS_CHUNKED_ARRAY_OOP_MASK)); |
| 0 | 133 assert(!is_oop_masked((oop*) ret), "invariant"); |
| 134 return ret; | |
| 135 } | |
| 136 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
137 template <class T> void process_array_chunk_work(oop obj, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
138 int start, int end); |
| 0 | 139 void process_array_chunk(oop old); |
| 140 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
141 template <class T> void push_depth(T* p) { |
| 1638 | 142 claimed_stack_depth()->push(p); |
| 0 | 143 } |
| 144 | |
| 145 protected: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
146 static OopStarTaskQueueSet* stack_array_depth() { return _stack_array_depth; } |
| 0 | 147 public: |
| 148 // Static | |
| 149 static void initialize(); | |
| 150 | |
| 151 static void pre_scavenge(); | |
| 152 static void post_scavenge(); | |
| 153 | |
| 154 static PSPromotionManager* gc_thread_promotion_manager(int index); | |
| 155 static PSPromotionManager* vm_thread_promotion_manager(); | |
| 156 | |
| 157 static bool steal_depth(int queue_num, int* seed, StarTask& t) { | |
| 158 return stack_array_depth()->steal(queue_num, seed, t); | |
| 159 } | |
| 160 | |
| 161 PSPromotionManager(); | |
| 162 | |
| 163 // Accessors | |
| 164 OopStarTaskQueue* claimed_stack_depth() { | |
| 165 return &_claimed_stack_depth; | |
| 166 } | |
| 167 | |
| 168 bool young_gen_is_full() { return _young_gen_is_full; } | |
| 169 | |
| 170 bool old_gen_is_full() { return _old_gen_is_full; } | |
| 171 void set_old_gen_is_full(bool state) { _old_gen_is_full = state; } | |
| 172 | |
| 173 // Promotion methods | |
| 4909 | 174 template<bool promote_immediately> oop copy_to_survivor_space(oop o); |
| 0 | 175 oop oop_promotion_failed(oop obj, markOop obj_mark); |
| 176 | |
| 177 void reset(); | |
| 178 | |
| 179 void flush_labs(); | |
| 180 void drain_stacks(bool totally_drain) { | |
|
1706
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1665
diff
changeset
|
181 drain_stacks_depth(totally_drain); |
| 0 | 182 } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
183 public: |
| 0 | 184 void drain_stacks_cond_depth() { |
| 185 if (claimed_stack_depth()->size() > _target_stack_size) { | |
| 186 drain_stacks_depth(false); | |
| 187 } | |
| 188 } | |
| 189 void drain_stacks_depth(bool totally_drain); | |
| 190 | |
| 191 bool stacks_empty() { | |
|
1706
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1665
diff
changeset
|
192 return claimed_stack_depth()->is_empty(); |
| 0 | 193 } |
| 194 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
195 inline void process_popped_location_depth(StarTask p); |
| 0 | 196 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
197 template <class T> inline void claim_or_forward_depth(T* p); |
| 0 | 198 |
| 1665 | 199 TASKQUEUE_STATS_ONLY(inline void record_steal(StarTask& p);) |
| 0 | 200 }; |
| 1972 | 201 |
| 202 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP |