Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp @ 113:ba764ed4b6f2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold
author coleenp
date Sun, 13 Apr 2008 17:43:42 -0400
parents a61af66fc99e
children d1605aabd0a1
comparison
equal deleted inserted replaced
110:a49a647afe9a 113:ba764ed4b6f2
39 // End move to some global location 39 // End move to some global location
40 40
41 class MutableSpace; 41 class MutableSpace;
42 class PSOldGen; 42 class PSOldGen;
43 class ParCompactionManager; 43 class ParCompactionManager;
44
45 #define PS_CHUNKED_ARRAY_OOP_MASK 1
46 44
47 #define PS_PM_STATS 0 45 #define PS_PM_STATS 0
48 46
49 class PSPromotionManager : public CHeapObj { 47 class PSPromotionManager : public CHeapObj {
50 friend class PSScavenge; 48 friend class PSScavenge;
78 bool _young_gen_is_full; 76 bool _young_gen_is_full;
79 bool _old_gen_is_full; 77 bool _old_gen_is_full;
80 PrefetchQueue _prefetch_queue; 78 PrefetchQueue _prefetch_queue;
81 79
82 OopStarTaskQueue _claimed_stack_depth; 80 OopStarTaskQueue _claimed_stack_depth;
83 GrowableArray<oop*>* _overflow_stack_depth; 81 GrowableArray<StarTask>* _overflow_stack_depth;
84 OopTaskQueue _claimed_stack_breadth; 82 OopTaskQueue _claimed_stack_breadth;
85 GrowableArray<oop>* _overflow_stack_breadth; 83 GrowableArray<oop>* _overflow_stack_breadth;
86 84
87 bool _depth_first; 85 bool _depth_first;
88 bool _totally_drain; 86 bool _totally_drain;
90 88
91 uint _array_chunk_size; 89 uint _array_chunk_size;
92 uint _min_array_size_for_chunking; 90 uint _min_array_size_for_chunking;
93 91
94 // Accessors 92 // Accessors
95 static PSOldGen* old_gen() { return _old_gen; } 93 static PSOldGen* old_gen() { return _old_gen; }
96 static MutableSpace* young_space() { return _young_space; } 94 static MutableSpace* young_space() { return _young_space; }
97 95
98 inline static PSPromotionManager* manager_array(int index); 96 inline static PSPromotionManager* manager_array(int index);
99 97 template <class T> inline void claim_or_forward_internal_depth(T* p);
100 GrowableArray<oop*>* overflow_stack_depth() { return _overflow_stack_depth; } 98 template <class T> inline void claim_or_forward_internal_breadth(T* p);
101 GrowableArray<oop>* overflow_stack_breadth() { return _overflow_stack_breadth; } 99
100 GrowableArray<StarTask>* overflow_stack_depth() { return _overflow_stack_depth; }
101 GrowableArray<oop>* overflow_stack_breadth() { return _overflow_stack_breadth; }
102 102
103 // On the task queues we push reference locations as well as 103 // On the task queues we push reference locations as well as
104 // partially-scanned arrays (in the latter case, we push an oop to 104 // partially-scanned arrays (in the latter case, we push an oop to
105 // the from-space image of the array and the length on the 105 // the from-space image of the array and the length on the
106 // from-space image indicates how many entries on the array we still 106 // from-space image indicates how many entries on the array we still
114 // oop*). This is because of the difference in types between what 114 // oop*). This is because of the difference in types between what
115 // the task queue holds (oop*) and oops to partially-scanned arrays 115 // the task queue holds (oop*) and oops to partially-scanned arrays
116 // (oop). We do all the necessary casting in the mask / unmask 116 // (oop). We do all the necessary casting in the mask / unmask
117 // methods to avoid sprinkling the rest of the code with more casts. 117 // methods to avoid sprinkling the rest of the code with more casts.
118 118
119 bool is_oop_masked(oop* p) { 119 // These are added to the taskqueue so PS_CHUNKED_ARRAY_OOP_MASK (or any
120 return ((intptr_t) p & PS_CHUNKED_ARRAY_OOP_MASK) == PS_CHUNKED_ARRAY_OOP_MASK; 120 // future masks) can't conflict with COMPRESSED_OOP_MASK
121 #define PS_CHUNKED_ARRAY_OOP_MASK 0x2
122
123 bool is_oop_masked(StarTask p) {
124 // If something is marked chunked it's always treated like wide oop*
125 return (((intptr_t)(oop*)p) & PS_CHUNKED_ARRAY_OOP_MASK) ==
126 PS_CHUNKED_ARRAY_OOP_MASK;
121 } 127 }
122 128
123 oop* mask_chunked_array_oop(oop obj) { 129 oop* mask_chunked_array_oop(oop obj) {
124 assert(!is_oop_masked((oop*) obj), "invariant"); 130 assert(!is_oop_masked((oop*) obj), "invariant");
125 oop* ret = (oop*) ((intptr_t) obj | PS_CHUNKED_ARRAY_OOP_MASK); 131 oop* ret = (oop*) ((uintptr_t)obj | PS_CHUNKED_ARRAY_OOP_MASK);
126 assert(is_oop_masked(ret), "invariant"); 132 assert(is_oop_masked(ret), "invariant");
127 return ret; 133 return ret;
128 } 134 }
129 135
130 oop unmask_chunked_array_oop(oop* p) { 136 oop unmask_chunked_array_oop(StarTask p) {
131 assert(is_oop_masked(p), "invariant"); 137 assert(is_oop_masked(p), "invariant");
132 oop ret = oop((intptr_t) p & ~PS_CHUNKED_ARRAY_OOP_MASK); 138 assert(!p.is_narrow(), "chunked array oops cannot be narrow");
139 oop *chunk = (oop*)p; // cast p to oop (uses conversion operator)
140 oop ret = oop((oop*)((uintptr_t)chunk & ~PS_CHUNKED_ARRAY_OOP_MASK));
133 assert(!is_oop_masked((oop*) ret), "invariant"); 141 assert(!is_oop_masked((oop*) ret), "invariant");
134 return ret; 142 return ret;
135 } 143 }
136 144
145 template <class T> void process_array_chunk_work(oop obj,
146 int start, int end);
137 void process_array_chunk(oop old); 147 void process_array_chunk(oop old);
138 148
139 void push_depth(oop* p) { 149 template <class T> void push_depth(T* p) {
140 assert(depth_first(), "pre-condition"); 150 assert(depth_first(), "pre-condition");
141 151
142 #if PS_PM_STATS 152 #if PS_PM_STATS
143 ++_total_pushes; 153 ++_total_pushes;
144 #endif // PS_PM_STATS 154 #endif // PS_PM_STATS
173 #endif // PS_PM_STATS 183 #endif // PS_PM_STATS
174 } 184 }
175 } 185 }
176 186
177 protected: 187 protected:
178 static OopStarTaskQueueSet* stack_array_depth() { return _stack_array_depth; } 188 static OopStarTaskQueueSet* stack_array_depth() { return _stack_array_depth; }
179 static OopTaskQueueSet* stack_array_breadth() { return _stack_array_breadth; } 189 static OopTaskQueueSet* stack_array_breadth() { return _stack_array_breadth; }
180 190
181 public: 191 public:
182 // Static 192 // Static
183 static void initialize(); 193 static void initialize();
225 drain_stacks_depth(totally_drain); 235 drain_stacks_depth(totally_drain);
226 } else { 236 } else {
227 drain_stacks_breadth(totally_drain); 237 drain_stacks_breadth(totally_drain);
228 } 238 }
229 } 239 }
240 public:
230 void drain_stacks_cond_depth() { 241 void drain_stacks_cond_depth() {
231 if (claimed_stack_depth()->size() > _target_stack_size) { 242 if (claimed_stack_depth()->size() > _target_stack_size) {
232 drain_stacks_depth(false); 243 drain_stacks_depth(false);
233 } 244 }
234 } 245 }
254 } 265 }
255 bool depth_first() { 266 bool depth_first() {
256 return _depth_first; 267 return _depth_first;
257 } 268 }
258 269
259 inline void process_popped_location_depth(oop* p); 270 inline void process_popped_location_depth(StarTask p);
260 271
261 inline void flush_prefetch_queue(); 272 inline void flush_prefetch_queue();
262 273 template <class T> inline void claim_or_forward_depth(T* p);
263 inline void claim_or_forward_depth(oop* p); 274 template <class T> inline void claim_or_forward_breadth(T* p);
264 inline void claim_or_forward_internal_depth(oop* p);
265
266 inline void claim_or_forward_breadth(oop* p);
267 inline void claim_or_forward_internal_breadth(oop* p);
268 275
269 #if PS_PM_STATS 276 #if PS_PM_STATS
270 void increment_steals(oop* p = NULL) { 277 void increment_steals(oop* p = NULL) {
271 _total_steals += 1; 278 _total_steals += 1;
272 if (p != NULL && is_oop_masked(p)) { 279 if (p != NULL && is_oop_masked(p)) {