Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @ 94:0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
Summary: The option CMSInitiatingPermOccupancyFraction now controls perm triggering threshold. Even though the actual value of the threshold has not yet been changed, so there is no change in policy, we now have the infrastructure in place for dynamically deciding when to collect the perm gen, an issue that will be addressed in the near future.
Reviewed-by: jmasa
author | ysr |
---|---|
date | Sun, 16 Mar 2008 21:57:25 -0700 |
parents | a61af66fc99e |
children | ba764ed4b6f2 |
rev | line source |
---|---|
0 | 1 /* |
2 * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 // ConcurrentMarkSweepGeneration is in support of a concurrent | |
26 // mark-sweep old generation in the Detlefs-Printezis--Boehm-Demers-Schenker | |
27 // style. We assume, for now, that this generation is always the | |
28 // seniormost generation (modulo the PermGeneration), and for simplicity | |
29 // in the first implementation, that this generation is a single compactible | |
30 // space. Neither of these restrictions appears essential, and will be | |
31 // relaxed in the future when more time is available to implement the | |
32 // greater generality (and there's a need for it). | |
33 // | |
34 // Concurrent mode failures are currently handled by | |
35 // means of a sliding mark-compact. | |
36 | |
37 class CMSAdaptiveSizePolicy; | |
38 class CMSConcMarkingTask; | |
39 class CMSGCAdaptivePolicyCounters; | |
40 class ConcurrentMarkSweepGeneration; | |
41 class ConcurrentMarkSweepPolicy; | |
42 class ConcurrentMarkSweepThread; | |
43 class CompactibleFreeListSpace; | |
44 class FreeChunk; | |
45 class PromotionInfo; | |
46 class ScanMarkedObjectsAgainCarefullyClosure; | |
47 | |
48 // A generic CMS bit map. It's the basis for both the CMS marking bit map | |
49 // as well as for the mod union table (in each case only a subset of the | |
50 // methods are used). This is essentially a wrapper around the BitMap class, | |
51 // with one bit per (1<<_shifter) HeapWords. (i.e. for the marking bit map, | |
52 // we have _shifter == 0. and for the mod union table we have | |
53 // shifter == CardTableModRefBS::card_shift - LogHeapWordSize.) | |
54 // XXX 64-bit issues in BitMap? | |
55 class CMSBitMap VALUE_OBJ_CLASS_SPEC { | |
56 friend class VMStructs; | |
57 | |
58 HeapWord* _bmStartWord; // base address of range covered by map | |
59 size_t _bmWordSize; // map size (in #HeapWords covered) | |
60 const int _shifter; // shifts to convert HeapWord to bit position | |
61 VirtualSpace _virtual_space; // underlying the bit map | |
62 BitMap _bm; // the bit map itself | |
63 public: | |
64 Mutex* const _lock; // mutex protecting _bm; | |
65 | |
66 public: | |
67 // constructor | |
68 CMSBitMap(int shifter, int mutex_rank, const char* mutex_name); | |
69 | |
70 // allocates the actual storage for the map | |
71 bool allocate(MemRegion mr); | |
72 // field getter | |
73 Mutex* lock() const { return _lock; } | |
74 // locking verifier convenience function | |
75 void assert_locked() const PRODUCT_RETURN; | |
76 | |
77 // inquiries | |
78 HeapWord* startWord() const { return _bmStartWord; } | |
79 size_t sizeInWords() const { return _bmWordSize; } | |
80 size_t sizeInBits() const { return _bm.size(); } | |
81 // the following is one past the last word in space | |
82 HeapWord* endWord() const { return _bmStartWord + _bmWordSize; } | |
83 | |
84 // reading marks | |
85 bool isMarked(HeapWord* addr) const; | |
86 bool par_isMarked(HeapWord* addr) const; // do not lock checks | |
87 bool isUnmarked(HeapWord* addr) const; | |
88 bool isAllClear() const; | |
89 | |
90 // writing marks | |
91 void mark(HeapWord* addr); | |
92 // For marking by parallel GC threads; | |
93 // returns true if we did, false if another thread did | |
94 bool par_mark(HeapWord* addr); | |
95 | |
96 void mark_range(MemRegion mr); | |
97 void par_mark_range(MemRegion mr); | |
98 void mark_large_range(MemRegion mr); | |
99 void par_mark_large_range(MemRegion mr); | |
100 void par_clear(HeapWord* addr); // For unmarking by parallel GC threads. | |
101 void clear_range(MemRegion mr); | |
102 void par_clear_range(MemRegion mr); | |
103 void clear_large_range(MemRegion mr); | |
104 void par_clear_large_range(MemRegion mr); | |
105 void clear_all(); | |
106 void clear_all_incrementally(); // Not yet implemented!! | |
107 | |
108 NOT_PRODUCT( | |
109 // checks the memory region for validity | |
110 void region_invariant(MemRegion mr); | |
111 ) | |
112 | |
113 // iteration | |
114 void iterate(BitMapClosure* cl) { | |
115 _bm.iterate(cl); | |
116 } | |
117 void iterate(BitMapClosure* cl, HeapWord* left, HeapWord* right); | |
118 void dirty_range_iterate_clear(MemRegionClosure* cl); | |
119 void dirty_range_iterate_clear(MemRegion mr, MemRegionClosure* cl); | |
120 | |
121 // auxiliary support for iteration | |
122 HeapWord* getNextMarkedWordAddress(HeapWord* addr) const; | |
123 HeapWord* getNextMarkedWordAddress(HeapWord* start_addr, | |
124 HeapWord* end_addr) const; | |
125 HeapWord* getNextUnmarkedWordAddress(HeapWord* addr) const; | |
126 HeapWord* getNextUnmarkedWordAddress(HeapWord* start_addr, | |
127 HeapWord* end_addr) const; | |
128 MemRegion getAndClearMarkedRegion(HeapWord* addr); | |
129 MemRegion getAndClearMarkedRegion(HeapWord* start_addr, | |
130 HeapWord* end_addr); | |
131 | |
132 // conversion utilities | |
133 HeapWord* offsetToHeapWord(size_t offset) const; | |
134 size_t heapWordToOffset(HeapWord* addr) const; | |
135 size_t heapWordDiffToOffsetDiff(size_t diff) const; | |
136 | |
137 // debugging | |
138 // is this address range covered by the bit-map? | |
139 NOT_PRODUCT( | |
140 bool covers(MemRegion mr) const; | |
141 bool covers(HeapWord* start, size_t size = 0) const; | |
142 ) | |
143 void verifyNoOneBitsInRange(HeapWord* left, HeapWord* right) PRODUCT_RETURN; | |
144 }; | |
145 | |
146 // Represents a marking stack used by the CMS collector. | |
147 // Ideally this should be GrowableArray<> just like MSC's marking stack(s). | |
148 class CMSMarkStack: public CHeapObj { | |
149 // | |
150 friend class CMSCollector; // to get at expasion stats further below | |
151 // | |
152 | |
153 VirtualSpace _virtual_space; // space for the stack | |
154 oop* _base; // bottom of stack | |
155 size_t _index; // one more than last occupied index | |
156 size_t _capacity; // max #elements | |
157 Mutex _par_lock; // an advisory lock used in case of parallel access | |
158 NOT_PRODUCT(size_t _max_depth;) // max depth plumbed during run | |
159 | |
160 protected: | |
161 size_t _hit_limit; // we hit max stack size limit | |
162 size_t _failed_double; // we failed expansion before hitting limit | |
163 | |
164 public: | |
165 CMSMarkStack(): | |
166 _par_lock(Mutex::event, "CMSMarkStack._par_lock", true), | |
167 _hit_limit(0), | |
168 _failed_double(0) {} | |
169 | |
170 bool allocate(size_t size); | |
171 | |
172 size_t capacity() const { return _capacity; } | |
173 | |
174 oop pop() { | |
175 if (!isEmpty()) { | |
176 return _base[--_index] ; | |
177 } | |
178 return NULL; | |
179 } | |
180 | |
181 bool push(oop ptr) { | |
182 if (isFull()) { | |
183 return false; | |
184 } else { | |
185 _base[_index++] = ptr; | |
186 NOT_PRODUCT(_max_depth = MAX2(_max_depth, _index)); | |
187 return true; | |
188 } | |
189 } | |
190 | |
191 bool isEmpty() const { return _index == 0; } | |
192 bool isFull() const { | |
193 assert(_index <= _capacity, "buffer overflow"); | |
194 return _index == _capacity; | |
195 } | |
196 | |
197 size_t length() { return _index; } | |
198 | |
199 // "Parallel versions" of some of the above | |
200 oop par_pop() { | |
201 // lock and pop | |
202 MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag); | |
203 return pop(); | |
204 } | |
205 | |
206 bool par_push(oop ptr) { | |
207 // lock and push | |
208 MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag); | |
209 return push(ptr); | |
210 } | |
211 | |
212 // Forcibly reset the stack, losing all of its contents. | |
213 void reset() { | |
214 _index = 0; | |
215 } | |
216 | |
217 // Expand the stack, typically in response to an overflow condition | |
218 void expand(); | |
219 | |
220 // Compute the least valued stack element. | |
221 oop least_value(HeapWord* low) { | |
222 oop least = (oop)low; | |
223 for (size_t i = 0; i < _index; i++) { | |
224 least = MIN2(least, _base[i]); | |
225 } | |
226 return least; | |
227 } | |
228 | |
229 // Exposed here to allow stack expansion in || case | |
230 Mutex* par_lock() { return &_par_lock; } | |
231 }; | |
232 | |
233 class CardTableRS; | |
234 class CMSParGCThreadState; | |
235 | |
236 class ModUnionClosure: public MemRegionClosure { | |
237 protected: | |
238 CMSBitMap* _t; | |
239 public: | |
240 ModUnionClosure(CMSBitMap* t): _t(t) { } | |
241 void do_MemRegion(MemRegion mr); | |
242 }; | |
243 | |
244 class ModUnionClosurePar: public ModUnionClosure { | |
245 public: | |
246 ModUnionClosurePar(CMSBitMap* t): ModUnionClosure(t) { } | |
247 void do_MemRegion(MemRegion mr); | |
248 }; | |
249 | |
250 // Survivor Chunk Array in support of parallelization of | |
251 // Survivor Space rescan. | |
252 class ChunkArray: public CHeapObj { | |
253 size_t _index; | |
254 size_t _capacity; | |
255 HeapWord** _array; // storage for array | |
256 | |
257 public: | |
258 ChunkArray() : _index(0), _capacity(0), _array(NULL) {} | |
259 ChunkArray(HeapWord** a, size_t c): | |
260 _index(0), _capacity(c), _array(a) {} | |
261 | |
262 HeapWord** array() { return _array; } | |
263 void set_array(HeapWord** a) { _array = a; } | |
264 | |
265 size_t capacity() { return _capacity; } | |
266 void set_capacity(size_t c) { _capacity = c; } | |
267 | |
268 size_t end() { | |
269 assert(_index < capacity(), "_index out of bounds"); | |
270 return _index; | |
271 } // exclusive | |
272 | |
273 HeapWord* nth(size_t n) { | |
274 assert(n < end(), "Out of bounds access"); | |
275 return _array[n]; | |
276 } | |
277 | |
278 void reset() { | |
279 _index = 0; | |
280 } | |
281 | |
282 void record_sample(HeapWord* p, size_t sz) { | |
283 // For now we do not do anything with the size | |
284 if (_index < _capacity) { | |
285 _array[_index++] = p; | |
286 } | |
287 } | |
288 }; | |
289 | |
290 // | |
291 // Timing, allocation and promotion statistics for gc scheduling and incremental | |
292 // mode pacing. Most statistics are exponential averages. | |
293 // | |
294 class CMSStats VALUE_OBJ_CLASS_SPEC { | |
295 private: | |
296 ConcurrentMarkSweepGeneration* const _cms_gen; // The cms (old) gen. | |
297 | |
298 // The following are exponential averages with factor alpha: | |
299 // avg = (100 - alpha) * avg + alpha * cur_sample | |
300 // | |
301 // The durations measure: end_time[n] - start_time[n] | |
302 // The periods measure: start_time[n] - start_time[n-1] | |
303 // | |
304 // The cms period and duration include only concurrent collections; time spent | |
305 // in foreground cms collections due to System.gc() or because of a failure to | |
306 // keep up are not included. | |
307 // | |
308 // There are 3 alphas to "bootstrap" the statistics. The _saved_alpha is the | |
309 // real value, but is used only after the first period. A value of 100 is | |
310 // used for the first sample so it gets the entire weight. | |
311 unsigned int _saved_alpha; // 0-100 | |
312 unsigned int _gc0_alpha; | |
313 unsigned int _cms_alpha; | |
314 | |
315 double _gc0_duration; | |
316 double _gc0_period; | |
317 size_t _gc0_promoted; // bytes promoted per gc0 | |
318 double _cms_duration; | |
319 double _cms_duration_pre_sweep; // time from initiation to start of sweep | |
320 double _cms_duration_per_mb; | |
321 double _cms_period; | |
322 size_t _cms_allocated; // bytes of direct allocation per gc0 period | |
323 | |
324 // Timers. | |
325 elapsedTimer _cms_timer; | |
326 TimeStamp _gc0_begin_time; | |
327 TimeStamp _cms_begin_time; | |
328 TimeStamp _cms_end_time; | |
329 | |
330 // Snapshots of the amount used in the CMS generation. | |
331 size_t _cms_used_at_gc0_begin; | |
332 size_t _cms_used_at_gc0_end; | |
333 size_t _cms_used_at_cms_begin; | |
334 | |
335 // Used to prevent the duty cycle from being reduced in the middle of a cms | |
336 // cycle. | |
337 bool _allow_duty_cycle_reduction; | |
338 | |
339 enum { | |
340 _GC0_VALID = 0x1, | |
341 _CMS_VALID = 0x2, | |
342 _ALL_VALID = _GC0_VALID | _CMS_VALID | |
343 }; | |
344 | |
345 unsigned int _valid_bits; | |
346 | |
347 unsigned int _icms_duty_cycle; // icms duty cycle (0-100). | |
348 | |
349 protected: | |
350 | |
351 // Return a duty cycle that avoids wild oscillations, by limiting the amount | |
352 // of change between old_duty_cycle and new_duty_cycle (the latter is treated | |
353 // as a recommended value). | |
354 static unsigned int icms_damped_duty_cycle(unsigned int old_duty_cycle, | |
355 unsigned int new_duty_cycle); | |
356 unsigned int icms_update_duty_cycle_impl(); | |
357 | |
358 public: | |
359 CMSStats(ConcurrentMarkSweepGeneration* cms_gen, | |
360 unsigned int alpha = CMSExpAvgFactor); | |
361 | |
362 // Whether or not the statistics contain valid data; higher level statistics | |
363 // cannot be called until this returns true (they require at least one young | |
364 // gen and one cms cycle to have completed). | |
365 bool valid() const; | |
366 | |
367 // Record statistics. | |
368 void record_gc0_begin(); | |
369 void record_gc0_end(size_t cms_gen_bytes_used); | |
370 void record_cms_begin(); | |
371 void record_cms_end(); | |
372 | |
373 // Allow management of the cms timer, which must be stopped/started around | |
374 // yield points. | |
375 elapsedTimer& cms_timer() { return _cms_timer; } | |
376 void start_cms_timer() { _cms_timer.start(); } | |
377 void stop_cms_timer() { _cms_timer.stop(); } | |
378 | |
379 // Basic statistics; units are seconds or bytes. | |
380 double gc0_period() const { return _gc0_period; } | |
381 double gc0_duration() const { return _gc0_duration; } | |
382 size_t gc0_promoted() const { return _gc0_promoted; } | |
383 double cms_period() const { return _cms_period; } | |
384 double cms_duration() const { return _cms_duration; } | |
385 double cms_duration_per_mb() const { return _cms_duration_per_mb; } | |
386 size_t cms_allocated() const { return _cms_allocated; } | |
387 | |
388 size_t cms_used_at_gc0_end() const { return _cms_used_at_gc0_end;} | |
389 | |
390 // Seconds since the last background cms cycle began or ended. | |
391 double cms_time_since_begin() const; | |
392 double cms_time_since_end() const; | |
393 | |
394 // Higher level statistics--caller must check that valid() returns true before | |
395 // calling. | |
396 | |
397 // Returns bytes promoted per second of wall clock time. | |
398 double promotion_rate() const; | |
399 | |
400 // Returns bytes directly allocated per second of wall clock time. | |
401 double cms_allocation_rate() const; | |
402 | |
403 // Rate at which space in the cms generation is being consumed (sum of the | |
404 // above two). | |
405 double cms_consumption_rate() const; | |
406 | |
407 // Returns an estimate of the number of seconds until the cms generation will | |
408 // fill up, assuming no collection work is done. | |
409 double time_until_cms_gen_full() const; | |
410 | |
411 // Returns an estimate of the number of seconds remaining until | |
412 // the cms generation collection should start. | |
413 double time_until_cms_start() const; | |
414 | |
415 // End of higher level statistics. | |
416 | |
417 // Returns the cms incremental mode duty cycle, as a percentage (0-100). | |
418 unsigned int icms_duty_cycle() const { return _icms_duty_cycle; } | |
419 | |
420 // Update the duty cycle and return the new value. | |
421 unsigned int icms_update_duty_cycle(); | |
422 | |
423 // Debugging. | |
424 void print_on(outputStream* st) const PRODUCT_RETURN; | |
425 void print() const { print_on(gclog_or_tty); } | |
426 }; | |
427 | |
428 // A closure related to weak references processing which | |
429 // we embed in the CMSCollector, since we need to pass | |
430 // it to the reference processor for secondary filtering | |
431 // of references based on reachability of referent; | |
432 // see role of _is_alive_non_header closure in the | |
433 // ReferenceProcessor class. | |
434 // For objects in the CMS generation, this closure checks | |
435 // if the object is "live" (reachable). Used in weak | |
436 // reference processing. | |
437 class CMSIsAliveClosure: public BoolObjectClosure { | |
438 MemRegion _span; | |
439 const CMSBitMap* _bit_map; | |
440 | |
441 friend class CMSCollector; | |
442 protected: | |
443 void set_span(MemRegion span) { _span = span; } | |
444 public: | |
445 CMSIsAliveClosure(CMSBitMap* bit_map): | |
446 _bit_map(bit_map) { } | |
447 | |
448 CMSIsAliveClosure(MemRegion span, | |
449 CMSBitMap* bit_map): | |
450 _span(span), | |
451 _bit_map(bit_map) { } | |
452 void do_object(oop obj) { | |
453 assert(false, "not to be invoked"); | |
454 } | |
455 bool do_object_b(oop obj); | |
456 }; | |
457 | |
458 | |
459 // Implements AbstractRefProcTaskExecutor for CMS. | |
460 class CMSRefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
461 public: | |
462 | |
463 CMSRefProcTaskExecutor(CMSCollector& collector) | |
464 : _collector(collector) | |
465 { } | |
466 | |
467 // Executes a task using worker threads. | |
468 virtual void execute(ProcessTask& task); | |
469 virtual void execute(EnqueueTask& task); | |
470 private: | |
471 CMSCollector& _collector; | |
472 }; | |
473 | |
474 | |
475 class CMSCollector: public CHeapObj { | |
476 friend class VMStructs; | |
477 friend class ConcurrentMarkSweepThread; | |
478 friend class ConcurrentMarkSweepGeneration; | |
479 friend class CompactibleFreeListSpace; | |
480 friend class CMSParRemarkTask; | |
481 friend class CMSConcMarkingTask; | |
482 friend class CMSRefProcTaskProxy; | |
483 friend class CMSRefProcTaskExecutor; | |
484 friend class ScanMarkedObjectsAgainCarefullyClosure; // for sampling eden | |
485 friend class SurvivorSpacePrecleanClosure; // --- ditto ------- | |
486 friend class PushOrMarkClosure; // to access _restart_addr | |
487 friend class Par_PushOrMarkClosure; // to access _restart_addr | |
488 friend class MarkFromRootsClosure; // -- ditto -- | |
489 // ... and for clearing cards | |
490 friend class Par_MarkFromRootsClosure; // to access _restart_addr | |
491 // ... and for clearing cards | |
492 friend class Par_ConcMarkingClosure; // to access _restart_addr etc. | |
493 friend class MarkFromRootsVerifyClosure; // to access _restart_addr | |
494 friend class PushAndMarkVerifyClosure; // -- ditto -- | |
495 friend class MarkRefsIntoAndScanClosure; // to access _overflow_list | |
496 friend class PushAndMarkClosure; // -- ditto -- | |
497 friend class Par_PushAndMarkClosure; // -- ditto -- | |
498 friend class CMSKeepAliveClosure; // -- ditto -- | |
499 friend class CMSDrainMarkingStackClosure; // -- ditto -- | |
500 friend class CMSInnerParMarkAndPushClosure; // -- ditto -- | |
501 NOT_PRODUCT(friend class ScanMarkedObjectsAgainClosure;) // assertion on _overflow_list | |
502 friend class ReleaseForegroundGC; // to access _foregroundGCShouldWait | |
503 friend class VM_CMS_Operation; | |
504 friend class VM_CMS_Initial_Mark; | |
505 friend class VM_CMS_Final_Remark; | |
506 | |
507 private: | |
508 jlong _time_of_last_gc; | |
509 void update_time_of_last_gc(jlong now) { | |
510 _time_of_last_gc = now; | |
511 } | |
512 | |
513 OopTaskQueueSet* _task_queues; | |
514 | |
515 // Overflow list of grey objects, threaded through mark-word | |
516 // Manipulated with CAS in the parallel/multi-threaded case. | |
517 oop _overflow_list; | |
518 // The following array-pair keeps track of mark words | |
519 // displaced for accomodating overflow list above. | |
520 // This code will likely be revisited under RFE#4922830. | |
521 GrowableArray<oop>* _preserved_oop_stack; | |
522 GrowableArray<markOop>* _preserved_mark_stack; | |
523 | |
524 int* _hash_seed; | |
525 | |
526 // In support of multi-threaded concurrent phases | |
527 YieldingFlexibleWorkGang* _conc_workers; | |
528 | |
529 // Performance Counters | |
530 CollectorCounters* _gc_counters; | |
531 | |
532 // Initialization Errors | |
533 bool _completed_initialization; | |
534 | |
535 // In support of ExplicitGCInvokesConcurrent | |
536 static bool _full_gc_requested; | |
537 unsigned int _collection_count_start; | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
538 |
0 | 539 // Should we unload classes this concurrent cycle? |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
540 bool _should_unload_classes; |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
541 unsigned int _concurrent_cycles_since_last_unload; |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
542 unsigned int concurrent_cycles_since_last_unload() const { |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
543 return _concurrent_cycles_since_last_unload; |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
544 } |
0 | 545 // Did we (allow) unload classes in the previous concurrent cycle? |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
546 bool unloaded_classes_last_cycle() const { |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
547 return concurrent_cycles_since_last_unload() == 0; |
0 | 548 } |
549 | |
550 // Verification support | |
551 CMSBitMap _verification_mark_bm; | |
552 void verify_after_remark_work_1(); | |
553 void verify_after_remark_work_2(); | |
554 | |
555 // true if any verification flag is on. | |
556 bool _verifying; | |
557 bool verifying() const { return _verifying; } | |
558 void set_verifying(bool v) { _verifying = v; } | |
559 | |
560 // Collector policy | |
561 ConcurrentMarkSweepPolicy* _collector_policy; | |
562 ConcurrentMarkSweepPolicy* collector_policy() { return _collector_policy; } | |
563 | |
564 // Check whether the gc time limit has been | |
565 // exceeded and set the size policy flag | |
566 // appropriately. | |
567 void check_gc_time_limit(); | |
568 // XXX Move these to CMSStats ??? FIX ME !!! | |
569 elapsedTimer _sweep_timer; | |
570 AdaptivePaddedAverage _sweep_estimate; | |
571 | |
572 protected: | |
573 ConcurrentMarkSweepGeneration* _cmsGen; // old gen (CMS) | |
574 ConcurrentMarkSweepGeneration* _permGen; // perm gen | |
575 MemRegion _span; // span covering above two | |
576 CardTableRS* _ct; // card table | |
577 | |
578 // CMS marking support structures | |
579 CMSBitMap _markBitMap; | |
580 CMSBitMap _modUnionTable; | |
581 CMSMarkStack _markStack; | |
582 CMSMarkStack _revisitStack; // used to keep track of klassKlass objects | |
583 // to revisit | |
584 CMSBitMap _perm_gen_verify_bit_map; // Mark bit map for perm gen verification support. | |
585 | |
586 HeapWord* _restart_addr; // in support of marking stack overflow | |
587 void lower_restart_addr(HeapWord* low); | |
588 | |
589 // Counters in support of marking stack / work queue overflow handling: | |
590 // a non-zero value indicates certain types of overflow events during | |
591 // the current CMS cycle and could lead to stack resizing efforts at | |
592 // an opportune future time. | |
593 size_t _ser_pmc_preclean_ovflw; | |
594 size_t _ser_pmc_remark_ovflw; | |
595 size_t _par_pmc_remark_ovflw; | |
596 size_t _ser_kac_ovflw; | |
597 size_t _par_kac_ovflw; | |
598 NOT_PRODUCT(size_t _num_par_pushes;) | |
599 | |
600 // ("Weak") Reference processing support | |
601 ReferenceProcessor* _ref_processor; | |
602 CMSIsAliveClosure _is_alive_closure; | |
603 // keep this textually after _markBitMap; c'tor dependency | |
604 | |
605 ConcurrentMarkSweepThread* _cmsThread; // the thread doing the work | |
606 ModUnionClosure _modUnionClosure; | |
607 ModUnionClosurePar _modUnionClosurePar; | |
608 | |
609 // CMS abstract state machine | |
610 // initial_state: Idling | |
611 // next_state(Idling) = {Marking} | |
612 // next_state(Marking) = {Precleaning, Sweeping} | |
613 // next_state(Precleaning) = {AbortablePreclean, FinalMarking} | |
614 // next_state(AbortablePreclean) = {FinalMarking} | |
615 // next_state(FinalMarking) = {Sweeping} | |
616 // next_state(Sweeping) = {Resizing} | |
617 // next_state(Resizing) = {Resetting} | |
618 // next_state(Resetting) = {Idling} | |
619 // The numeric values below are chosen so that: | |
620 // . _collectorState <= Idling == post-sweep && pre-mark | |
621 // . _collectorState in (Idling, Sweeping) == {initial,final}marking || | |
622 // precleaning || abortablePrecleanb | |
623 enum CollectorState { | |
624 Resizing = 0, | |
625 Resetting = 1, | |
626 Idling = 2, | |
627 InitialMarking = 3, | |
628 Marking = 4, | |
629 Precleaning = 5, | |
630 AbortablePreclean = 6, | |
631 FinalMarking = 7, | |
632 Sweeping = 8 | |
633 }; | |
634 static CollectorState _collectorState; | |
635 | |
636 // State related to prologue/epilogue invocation for my generations | |
637 bool _between_prologue_and_epilogue; | |
638 | |
639 // Signalling/State related to coordination between fore- and backgroud GC | |
640 // Note: When the baton has been passed from background GC to foreground GC, | |
641 // _foregroundGCIsActive is true and _foregroundGCShouldWait is false. | |
642 static bool _foregroundGCIsActive; // true iff foreground collector is active or | |
643 // wants to go active | |
644 static bool _foregroundGCShouldWait; // true iff background GC is active and has not | |
645 // yet passed the baton to the foreground GC | |
646 | |
647 // Support for CMSScheduleRemark (abortable preclean) | |
648 bool _abort_preclean; | |
649 bool _start_sampling; | |
650 | |
651 int _numYields; | |
652 size_t _numDirtyCards; | |
653 uint _sweepCount; | |
654 // number of full gc's since the last concurrent gc. | |
655 uint _full_gcs_since_conc_gc; | |
656 | |
657 // occupancy used for bootstrapping stats | |
658 double _bootstrap_occupancy; | |
659 | |
660 // timer | |
661 elapsedTimer _timer; | |
662 | |
663 // Timing, allocation and promotion statistics, used for scheduling. | |
664 CMSStats _stats; | |
665 | |
666 // Allocation limits installed in the young gen, used only in | |
667 // CMSIncrementalMode. When an allocation in the young gen would cross one of | |
668 // these limits, the cms generation is notified and the cms thread is started | |
669 // or stopped, respectively. | |
670 HeapWord* _icms_start_limit; | |
671 HeapWord* _icms_stop_limit; | |
672 | |
673 enum CMS_op_type { | |
674 CMS_op_checkpointRootsInitial, | |
675 CMS_op_checkpointRootsFinal | |
676 }; | |
677 | |
678 void do_CMS_operation(CMS_op_type op); | |
679 bool stop_world_and_do(CMS_op_type op); | |
680 | |
681 OopTaskQueueSet* task_queues() { return _task_queues; } | |
682 int* hash_seed(int i) { return &_hash_seed[i]; } | |
683 YieldingFlexibleWorkGang* conc_workers() { return _conc_workers; } | |
684 | |
685 // Support for parallelizing Eden rescan in CMS remark phase | |
686 void sample_eden(); // ... sample Eden space top | |
687 | |
688 private: | |
689 // Support for parallelizing young gen rescan in CMS remark phase | |
690 Generation* _young_gen; // the younger gen | |
691 HeapWord** _top_addr; // ... Top of Eden | |
692 HeapWord** _end_addr; // ... End of Eden | |
693 HeapWord** _eden_chunk_array; // ... Eden partitioning array | |
694 size_t _eden_chunk_index; // ... top (exclusive) of array | |
695 size_t _eden_chunk_capacity; // ... max entries in array | |
696 | |
697 // Support for parallelizing survivor space rescan | |
698 HeapWord** _survivor_chunk_array; | |
699 size_t _survivor_chunk_index; | |
700 size_t _survivor_chunk_capacity; | |
701 size_t* _cursor; | |
702 ChunkArray* _survivor_plab_array; | |
703 | |
704 // Support for marking stack overflow handling | |
705 bool take_from_overflow_list(size_t num, CMSMarkStack* to_stack); | |
706 bool par_take_from_overflow_list(size_t num, OopTaskQueue* to_work_q); | |
707 void push_on_overflow_list(oop p); | |
708 void par_push_on_overflow_list(oop p); | |
709 // the following is, obviously, not, in general, "MT-stable" | |
710 bool overflow_list_is_empty() const; | |
711 | |
712 void preserve_mark_if_necessary(oop p); | |
713 void par_preserve_mark_if_necessary(oop p); | |
714 void preserve_mark_work(oop p, markOop m); | |
715 void restore_preserved_marks_if_any(); | |
716 NOT_PRODUCT(bool no_preserved_marks() const;) | |
717 // in support of testing overflow code | |
718 NOT_PRODUCT(int _overflow_counter;) | |
719 NOT_PRODUCT(bool simulate_overflow();) // sequential | |
720 NOT_PRODUCT(bool par_simulate_overflow();) // MT version | |
721 | |
722 int _roots_scanning_options; | |
723 int roots_scanning_options() const { return _roots_scanning_options; } | |
724 void add_root_scanning_option(int o) { _roots_scanning_options |= o; } | |
725 void remove_root_scanning_option(int o) { _roots_scanning_options &= ~o; } | |
726 | |
727 // CMS work methods | |
728 void checkpointRootsInitialWork(bool asynch); // initial checkpoint work | |
729 | |
730 // a return value of false indicates failure due to stack overflow | |
731 bool markFromRootsWork(bool asynch); // concurrent marking work | |
732 | |
733 public: // FIX ME!!! only for testing | |
734 bool do_marking_st(bool asynch); // single-threaded marking | |
735 bool do_marking_mt(bool asynch); // multi-threaded marking | |
736 | |
737 private: | |
738 | |
739 // concurrent precleaning work | |
740 size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen, | |
741 ScanMarkedObjectsAgainCarefullyClosure* cl); | |
742 size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen, | |
743 ScanMarkedObjectsAgainCarefullyClosure* cl); | |
744 // Does precleaning work, returning a quantity indicative of | |
745 // the amount of "useful work" done. | |
746 size_t preclean_work(bool clean_refs, bool clean_survivors); | |
747 void abortable_preclean(); // Preclean while looking for possible abort | |
748 void initialize_sequential_subtasks_for_young_gen_rescan(int i); | |
749 // Helper function for above; merge-sorts the per-thread plab samples | |
750 void merge_survivor_plab_arrays(ContiguousSpace* surv); | |
751 // Resets (i.e. clears) the per-thread plab sample vectors | |
752 void reset_survivor_plab_arrays(); | |
753 | |
754 // final (second) checkpoint work | |
755 void checkpointRootsFinalWork(bool asynch, bool clear_all_soft_refs, | |
756 bool init_mark_was_synchronous); | |
757 // work routine for parallel version of remark | |
758 void do_remark_parallel(); | |
759 // work routine for non-parallel version of remark | |
760 void do_remark_non_parallel(); | |
761 // reference processing work routine (during second checkpoint) | |
762 void refProcessingWork(bool asynch, bool clear_all_soft_refs); | |
763 | |
764 // concurrent sweeping work | |
765 void sweepWork(ConcurrentMarkSweepGeneration* gen, bool asynch); | |
766 | |
767 // (concurrent) resetting of support data structures | |
768 void reset(bool asynch); | |
769 | |
770 // Clear _expansion_cause fields of constituent generations | |
771 void clear_expansion_cause(); | |
772 | |
773 // An auxilliary method used to record the ends of | |
774 // used regions of each generation to limit the extent of sweep | |
775 void save_sweep_limits(); | |
776 | |
777 // Resize the generations included in the collector. | |
778 void compute_new_size(); | |
779 | |
780 // A work method used by foreground collection to determine | |
781 // what type of collection (compacting or not, continuing or fresh) | |
782 // it should do. | |
783 void decide_foreground_collection_type(bool clear_all_soft_refs, | |
784 bool* should_compact, bool* should_start_over); | |
785 | |
786 // A work method used by the foreground collector to do | |
787 // a mark-sweep-compact. | |
788 void do_compaction_work(bool clear_all_soft_refs); | |
789 | |
790 // A work method used by the foreground collector to do | |
791 // a mark-sweep, after taking over from a possibly on-going | |
792 // concurrent mark-sweep collection. | |
793 void do_mark_sweep_work(bool clear_all_soft_refs, | |
794 CollectorState first_state, bool should_start_over); | |
795 | |
796 // If the backgrould GC is active, acquire control from the background | |
797 // GC and do the collection. | |
798 void acquire_control_and_collect(bool full, bool clear_all_soft_refs); | |
799 | |
800 // For synchronizing passing of control from background to foreground | |
801 // GC. waitForForegroundGC() is called by the background | |
802 // collector. It if had to wait for a foreground collection, | |
803 // it returns true and the background collection should assume | |
804 // that the collection was finished by the foreground | |
805 // collector. | |
806 bool waitForForegroundGC(); | |
807 | |
808 // Incremental mode triggering: recompute the icms duty cycle and set the | |
809 // allocation limits in the young gen. | |
810 void icms_update_allocation_limits(); | |
811 | |
812 size_t block_size_using_printezis_bits(HeapWord* addr) const; | |
813 size_t block_size_if_printezis_bits(HeapWord* addr) const; | |
814 HeapWord* next_card_start_after_block(HeapWord* addr) const; | |
815 | |
816 void setup_cms_unloading_and_verification_state(); | |
817 public: | |
818 CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, | |
819 ConcurrentMarkSweepGeneration* permGen, | |
820 CardTableRS* ct, | |
821 ConcurrentMarkSweepPolicy* cp); | |
822 ConcurrentMarkSweepThread* cmsThread() { return _cmsThread; } | |
823 | |
824 ReferenceProcessor* ref_processor() { return _ref_processor; } | |
825 void ref_processor_init(); | |
826 | |
827 Mutex* bitMapLock() const { return _markBitMap.lock(); } | |
828 static CollectorState abstract_state() { return _collectorState; } | |
829 | |
830 bool should_abort_preclean() const; // Whether preclean should be aborted. | |
831 size_t get_eden_used() const; | |
832 size_t get_eden_capacity() const; | |
833 | |
834 ConcurrentMarkSweepGeneration* cmsGen() { return _cmsGen; } | |
835 | |
836 // locking checks | |
837 NOT_PRODUCT(static bool have_cms_token();) | |
838 | |
839 // XXXPERM bool should_collect(bool full, size_t size, bool tlab); | |
840 bool shouldConcurrentCollect(); | |
841 | |
842 void collect(bool full, | |
843 bool clear_all_soft_refs, | |
844 size_t size, | |
845 bool tlab); | |
846 void collect_in_background(bool clear_all_soft_refs); | |
847 void collect_in_foreground(bool clear_all_soft_refs); | |
848 | |
849 // In support of ExplicitGCInvokesConcurrent | |
850 static void request_full_gc(unsigned int full_gc_count); | |
851 // Should we unload classes in a particular concurrent cycle? | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
852 bool should_unload_classes() const { |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
853 return _should_unload_classes; |
0 | 854 } |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
855 bool update_should_unload_classes(); |
0 | 856 |
857 void direct_allocated(HeapWord* start, size_t size); | |
858 | |
859 // Object is dead if not marked and current phase is sweeping. | |
860 bool is_dead_obj(oop obj) const; | |
861 | |
862 // After a promotion (of "start"), do any necessary marking. | |
863 // If "par", then it's being done by a parallel GC thread. | |
864 // The last two args indicate if we need precise marking | |
865 // and if so the size of the object so it can be dirtied | |
866 // in its entirety. | |
867 void promoted(bool par, HeapWord* start, | |
868 bool is_obj_array, size_t obj_size); | |
869 | |
870 HeapWord* allocation_limit_reached(Space* space, HeapWord* top, | |
871 size_t word_size); | |
872 | |
873 void getFreelistLocks() const; | |
874 void releaseFreelistLocks() const; | |
875 bool haveFreelistLocks() const; | |
876 | |
877 // GC prologue and epilogue | |
878 void gc_prologue(bool full); | |
879 void gc_epilogue(bool full); | |
880 | |
881 jlong time_of_last_gc(jlong now) { | |
882 if (_collectorState <= Idling) { | |
883 // gc not in progress | |
884 return _time_of_last_gc; | |
885 } else { | |
886 // collection in progress | |
887 return now; | |
888 } | |
889 } | |
890 | |
891 // Support for parallel remark of survivor space | |
892 void* get_data_recorder(int thr_num); | |
893 | |
894 CMSBitMap* markBitMap() { return &_markBitMap; } | |
895 void directAllocated(HeapWord* start, size_t size); | |
896 | |
897 // main CMS steps and related support | |
898 void checkpointRootsInitial(bool asynch); | |
899 bool markFromRoots(bool asynch); // a return value of false indicates failure | |
900 // due to stack overflow | |
901 void preclean(); | |
902 void checkpointRootsFinal(bool asynch, bool clear_all_soft_refs, | |
903 bool init_mark_was_synchronous); | |
904 void sweep(bool asynch); | |
905 | |
906 // Check that the currently executing thread is the expected | |
907 // one (foreground collector or background collector). | |
908 void check_correct_thread_executing() PRODUCT_RETURN; | |
909 // XXXPERM void print_statistics() PRODUCT_RETURN; | |
910 | |
911 bool is_cms_reachable(HeapWord* addr); | |
912 | |
913 // Performance Counter Support | |
914 CollectorCounters* counters() { return _gc_counters; } | |
915 | |
916 // timer stuff | |
917 void startTimer() { assert(!_timer.is_active(), "Error"); _timer.start(); } | |
918 void stopTimer() { assert( _timer.is_active(), "Error"); _timer.stop(); } | |
919 void resetTimer() { assert(!_timer.is_active(), "Error"); _timer.reset(); } | |
920 double timerValue() { assert(!_timer.is_active(), "Error"); return _timer.seconds(); } | |
921 | |
922 int yields() { return _numYields; } | |
923 void resetYields() { _numYields = 0; } | |
924 void incrementYields() { _numYields++; } | |
925 void resetNumDirtyCards() { _numDirtyCards = 0; } | |
926 void incrementNumDirtyCards(size_t num) { _numDirtyCards += num; } | |
927 size_t numDirtyCards() { return _numDirtyCards; } | |
928 | |
929 static bool foregroundGCShouldWait() { return _foregroundGCShouldWait; } | |
930 static void set_foregroundGCShouldWait(bool v) { _foregroundGCShouldWait = v; } | |
931 static bool foregroundGCIsActive() { return _foregroundGCIsActive; } | |
932 static void set_foregroundGCIsActive(bool v) { _foregroundGCIsActive = v; } | |
933 uint sweepCount() const { return _sweepCount; } | |
934 void incrementSweepCount() { _sweepCount++; } | |
935 | |
936 // Timers/stats for gc scheduling and incremental mode pacing. | |
937 CMSStats& stats() { return _stats; } | |
938 | |
939 // Convenience methods that check whether CMSIncrementalMode is enabled and | |
940 // forward to the corresponding methods in ConcurrentMarkSweepThread. | |
941 static void start_icms(); | |
942 static void stop_icms(); // Called at the end of the cms cycle. | |
943 static void disable_icms(); // Called before a foreground collection. | |
944 static void enable_icms(); // Called after a foreground collection. | |
945 void icms_wait(); // Called at yield points. | |
946 | |
947 // Adaptive size policy | |
948 CMSAdaptiveSizePolicy* size_policy(); | |
949 CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters(); | |
950 | |
951 // debugging | |
952 void verify(bool); | |
953 bool verify_after_remark(); | |
954 void verify_ok_to_terminate() const PRODUCT_RETURN; | |
955 void verify_work_stacks_empty() const PRODUCT_RETURN; | |
956 void verify_overflow_empty() const PRODUCT_RETURN; | |
957 | |
958 // convenience methods in support of debugging | |
959 static const size_t skip_header_HeapWords() PRODUCT_RETURN0; | |
960 HeapWord* block_start(const void* p) const PRODUCT_RETURN0; | |
961 | |
962 // accessors | |
963 CMSMarkStack* verification_mark_stack() { return &_markStack; } | |
964 CMSBitMap* verification_mark_bm() { return &_verification_mark_bm; } | |
965 | |
966 // Get the bit map with a perm gen "deadness" information. | |
967 CMSBitMap* perm_gen_verify_bit_map() { return &_perm_gen_verify_bit_map; } | |
968 | |
969 // Initialization errors | |
970 bool completed_initialization() { return _completed_initialization; } | |
971 }; | |
972 | |
973 class CMSExpansionCause : public AllStatic { | |
974 public: | |
975 enum Cause { | |
976 _no_expansion, | |
977 _satisfy_free_ratio, | |
978 _satisfy_promotion, | |
979 _satisfy_allocation, | |
980 _allocate_par_lab, | |
981 _allocate_par_spooling_space, | |
982 _adaptive_size_policy | |
983 }; | |
984 // Return a string describing the cause of the expansion. | |
985 static const char* to_string(CMSExpansionCause::Cause cause); | |
986 }; | |
987 | |
988 class ConcurrentMarkSweepGeneration: public CardGeneration { | |
989 friend class VMStructs; | |
990 friend class ConcurrentMarkSweepThread; | |
991 friend class ConcurrentMarkSweep; | |
992 friend class CMSCollector; | |
993 protected: | |
994 static CMSCollector* _collector; // the collector that collects us | |
995 CompactibleFreeListSpace* _cmsSpace; // underlying space (only one for now) | |
996 | |
997 // Performance Counters | |
998 GenerationCounters* _gen_counters; | |
999 GSpaceCounters* _space_counters; | |
1000 | |
1001 // Words directly allocated, used by CMSStats. | |
1002 size_t _direct_allocated_words; | |
1003 | |
1004 // Non-product stat counters | |
1005 NOT_PRODUCT( | |
1006 int _numObjectsPromoted; | |
1007 int _numWordsPromoted; | |
1008 int _numObjectsAllocated; | |
1009 int _numWordsAllocated; | |
1010 ) | |
1011 | |
1012 // Used for sizing decisions | |
1013 bool _incremental_collection_failed; | |
1014 bool incremental_collection_failed() { | |
1015 return _incremental_collection_failed; | |
1016 } | |
1017 void set_incremental_collection_failed() { | |
1018 _incremental_collection_failed = true; | |
1019 } | |
1020 void clear_incremental_collection_failed() { | |
1021 _incremental_collection_failed = false; | |
1022 } | |
1023 | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1024 // accessors |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1025 void set_expansion_cause(CMSExpansionCause::Cause v) { _expansion_cause = v;} |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1026 CMSExpansionCause::Cause expansion_cause() const { return _expansion_cause; } |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1027 |
0 | 1028 private: |
1029 // For parallel young-gen GC support. | |
1030 CMSParGCThreadState** _par_gc_thread_states; | |
1031 | |
1032 // Reason generation was expanded | |
1033 CMSExpansionCause::Cause _expansion_cause; | |
1034 | |
1035 // In support of MinChunkSize being larger than min object size | |
1036 const double _dilatation_factor; | |
1037 | |
1038 enum CollectionTypes { | |
1039 Concurrent_collection_type = 0, | |
1040 MS_foreground_collection_type = 1, | |
1041 MSC_foreground_collection_type = 2, | |
1042 Unknown_collection_type = 3 | |
1043 }; | |
1044 | |
1045 CollectionTypes _debug_collection_type; | |
1046 | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1047 // Fraction of current occupancy at which to start a CMS collection which |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1048 // will collect this generation (at least). |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1049 double _initiating_occupancy; |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1050 |
0 | 1051 protected: |
1052 // Grow generation by specified size (returns false if unable to grow) | |
1053 bool grow_by(size_t bytes); | |
1054 // Grow generation to reserved size. | |
1055 bool grow_to_reserved(); | |
1056 // Shrink generation by specified size (returns false if unable to shrink) | |
1057 virtual void shrink_by(size_t bytes); | |
1058 | |
1059 // Update statistics for GC | |
1060 virtual void update_gc_stats(int level, bool full); | |
1061 | |
1062 // Maximum available space in the generation (including uncommitted) | |
1063 // space. | |
1064 size_t max_available() const; | |
1065 | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1066 // getter and initializer for _initiating_occupancy field. |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1067 double initiating_occupancy() const { return _initiating_occupancy; } |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1068 void init_initiating_occupancy(intx io, intx tr); |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1069 |
0 | 1070 public: |
1071 ConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size, | |
1072 int level, CardTableRS* ct, | |
1073 bool use_adaptive_freelists, | |
1074 FreeBlockDictionary::DictionaryChoice); | |
1075 | |
1076 // Accessors | |
1077 CMSCollector* collector() const { return _collector; } | |
1078 static void set_collector(CMSCollector* collector) { | |
1079 assert(_collector == NULL, "already set"); | |
1080 _collector = collector; | |
1081 } | |
1082 CompactibleFreeListSpace* cmsSpace() const { return _cmsSpace; } | |
1083 | |
1084 Mutex* freelistLock() const; | |
1085 | |
1086 virtual Generation::Name kind() { return Generation::ConcurrentMarkSweep; } | |
1087 | |
1088 // Adaptive size policy | |
1089 CMSAdaptiveSizePolicy* size_policy(); | |
1090 | |
1091 bool refs_discovery_is_atomic() const { return false; } | |
1092 bool refs_discovery_is_mt() const { | |
1093 // Note: CMS does MT-discovery during the parallel-remark | |
1094 // phases. Use ReferenceProcessorMTMutator to make refs | |
1095 // discovery MT-safe during such phases or other parallel | |
1096 // discovery phases in the future. This may all go away | |
1097 // if/when we decide that refs discovery is sufficiently | |
1098 // rare that the cost of the CAS's involved is in the | |
1099 // noise. That's a measurement that should be done, and | |
1100 // the code simplified if that turns out to be the case. | |
1101 return false; | |
1102 } | |
1103 | |
1104 // Override | |
1105 virtual void ref_processor_init(); | |
1106 | |
1107 void clear_expansion_cause() { _expansion_cause = CMSExpansionCause::_no_expansion; } | |
1108 | |
1109 // Space enquiries | |
1110 size_t capacity() const; | |
1111 size_t used() const; | |
1112 size_t free() const; | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1113 double occupancy() const { return ((double)used())/((double)capacity()); } |
0 | 1114 size_t contiguous_available() const; |
1115 size_t unsafe_max_alloc_nogc() const; | |
1116 | |
1117 // over-rides | |
1118 MemRegion used_region() const; | |
1119 MemRegion used_region_at_save_marks() const; | |
1120 | |
1121 // Does a "full" (forced) collection invoked on this generation collect | |
1122 // all younger generations as well? Note that the second conjunct is a | |
1123 // hack to allow the collection of the younger gen first if the flag is | |
1124 // set. This is better than using th policy's should_collect_gen0_first() | |
1125 // since that causes us to do an extra unnecessary pair of restart-&-stop-world. | |
1126 virtual bool full_collects_younger_generations() const { | |
1127 return UseCMSCompactAtFullCollection && !CollectGen0First; | |
1128 } | |
1129 | |
1130 void space_iterate(SpaceClosure* blk, bool usedOnly = false); | |
1131 | |
1132 // Support for compaction | |
1133 CompactibleSpace* first_compaction_space() const; | |
1134 // Adjust quantites in the generation affected by | |
1135 // the compaction. | |
1136 void reset_after_compaction(); | |
1137 | |
1138 // Allocation support | |
1139 HeapWord* allocate(size_t size, bool tlab); | |
1140 HeapWord* have_lock_and_allocate(size_t size, bool tlab); | |
1141 oop promote(oop obj, size_t obj_size, oop* ref); | |
1142 HeapWord* par_allocate(size_t size, bool tlab) { | |
1143 return allocate(size, tlab); | |
1144 } | |
1145 | |
1146 // Incremental mode triggering. | |
1147 HeapWord* allocation_limit_reached(Space* space, HeapWord* top, | |
1148 size_t word_size); | |
1149 | |
1150 // Used by CMSStats to track direct allocation. The value is sampled and | |
1151 // reset after each young gen collection. | |
1152 size_t direct_allocated_words() const { return _direct_allocated_words; } | |
1153 void reset_direct_allocated_words() { _direct_allocated_words = 0; } | |
1154 | |
1155 // Overrides for parallel promotion. | |
1156 virtual oop par_promote(int thread_num, | |
1157 oop obj, markOop m, size_t word_sz); | |
1158 // This one should not be called for CMS. | |
1159 virtual void par_promote_alloc_undo(int thread_num, | |
1160 HeapWord* obj, size_t word_sz); | |
1161 virtual void par_promote_alloc_done(int thread_num); | |
1162 virtual void par_oop_since_save_marks_iterate_done(int thread_num); | |
1163 | |
1164 virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes, | |
1165 bool younger_handles_promotion_failure) const; | |
1166 | |
1167 bool should_collect(bool full, size_t size, bool tlab); | |
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1168 virtual bool should_concurrent_collect() const; |
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1169 virtual bool is_too_full() const; |
0 | 1170 void collect(bool full, |
1171 bool clear_all_soft_refs, | |
1172 size_t size, | |
1173 bool tlab); | |
1174 | |
1175 HeapWord* expand_and_allocate(size_t word_size, | |
1176 bool tlab, | |
1177 bool parallel = false); | |
1178 | |
1179 // GC prologue and epilogue | |
1180 void gc_prologue(bool full); | |
1181 void gc_prologue_work(bool full, bool registerClosure, | |
1182 ModUnionClosure* modUnionClosure); | |
1183 void gc_epilogue(bool full); | |
1184 void gc_epilogue_work(bool full); | |
1185 | |
1186 // Time since last GC of this generation | |
1187 jlong time_of_last_gc(jlong now) { | |
1188 return collector()->time_of_last_gc(now); | |
1189 } | |
1190 void update_time_of_last_gc(jlong now) { | |
1191 collector()-> update_time_of_last_gc(now); | |
1192 } | |
1193 | |
1194 // Allocation failure | |
1195 void expand(size_t bytes, size_t expand_bytes, | |
1196 CMSExpansionCause::Cause cause); | |
1197 void shrink(size_t bytes); | |
1198 HeapWord* expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz); | |
1199 bool expand_and_ensure_spooling_space(PromotionInfo* promo); | |
1200 | |
1201 // Iteration support and related enquiries | |
1202 void save_marks(); | |
1203 bool no_allocs_since_save_marks(); | |
1204 void object_iterate_since_last_GC(ObjectClosure* cl); | |
1205 void younger_refs_iterate(OopsInGenClosure* cl); | |
1206 | |
1207 // Iteration support specific to CMS generations | |
1208 void save_sweep_limit(); | |
1209 | |
1210 // More iteration support | |
1211 virtual void oop_iterate(MemRegion mr, OopClosure* cl); | |
1212 virtual void oop_iterate(OopClosure* cl); | |
1213 virtual void object_iterate(ObjectClosure* cl); | |
1214 | |
1215 // Need to declare the full complement of closures, whether we'll | |
1216 // override them or not, or get message from the compiler: | |
1217 // oop_since_save_marks_iterate_nv hides virtual function... | |
1218 #define CMS_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
1219 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
1220 ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DECL) | |
1221 | |
1222 // Smart allocation XXX -- move to CFLSpace? | |
1223 void setNearLargestChunk(); | |
1224 bool isNearLargestChunk(HeapWord* addr); | |
1225 | |
1226 // Get the chunk at the end of the space. Delagates to | |
1227 // the space. | |
1228 FreeChunk* find_chunk_at_end(); | |
1229 | |
1230 // Overriding of unused functionality (sharing not yet supported with CMS) | |
1231 void pre_adjust_pointers(); | |
1232 void post_compact(); | |
1233 | |
1234 // Debugging | |
1235 void prepare_for_verify(); | |
1236 void verify(bool allow_dirty); | |
1237 void print_statistics() PRODUCT_RETURN; | |
1238 | |
1239 // Performance Counters support | |
1240 virtual void update_counters(); | |
1241 virtual void update_counters(size_t used); | |
1242 void initialize_performance_counters(); | |
1243 CollectorCounters* counters() { return collector()->counters(); } | |
1244 | |
1245 // Support for parallel remark of survivor space | |
1246 void* get_data_recorder(int thr_num) { | |
1247 //Delegate to collector | |
1248 return collector()->get_data_recorder(thr_num); | |
1249 } | |
1250 | |
1251 // Printing | |
1252 const char* name() const; | |
1253 virtual const char* short_name() const { return "CMS"; } | |
1254 void print() const; | |
1255 void printOccupancy(const char* s); | |
1256 bool must_be_youngest() const { return false; } | |
1257 bool must_be_oldest() const { return true; } | |
1258 | |
1259 void compute_new_size(); | |
1260 | |
1261 CollectionTypes debug_collection_type() { return _debug_collection_type; } | |
1262 void rotate_debug_collection_type(); | |
1263 }; | |
1264 | |
1265 class ASConcurrentMarkSweepGeneration : public ConcurrentMarkSweepGeneration { | |
1266 | |
1267 // Return the size policy from the heap's collector | |
1268 // policy casted to CMSAdaptiveSizePolicy*. | |
1269 CMSAdaptiveSizePolicy* cms_size_policy() const; | |
1270 | |
1271 // Resize the generation based on the adaptive size | |
1272 // policy. | |
1273 void resize(size_t cur_promo, size_t desired_promo); | |
1274 | |
1275 // Return the GC counters from the collector policy | |
1276 CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters(); | |
1277 | |
1278 virtual void shrink_by(size_t bytes); | |
1279 | |
1280 public: | |
1281 virtual void compute_new_size(); | |
1282 ASConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size, | |
1283 int level, CardTableRS* ct, | |
1284 bool use_adaptive_freelists, | |
1285 FreeBlockDictionary::DictionaryChoice | |
1286 dictionaryChoice) : | |
1287 ConcurrentMarkSweepGeneration(rs, initial_byte_size, level, ct, | |
1288 use_adaptive_freelists, dictionaryChoice) {} | |
1289 | |
1290 virtual const char* short_name() const { return "ASCMS"; } | |
1291 virtual Generation::Name kind() { return Generation::ASConcurrentMarkSweep; } | |
1292 | |
1293 virtual void update_counters(); | |
1294 virtual void update_counters(size_t used); | |
1295 }; | |
1296 | |
1297 // | |
1298 // Closures of various sorts used by CMS to accomplish its work | |
1299 // | |
1300 | |
1301 // This closure is used to check that a certain set of oops is empty. | |
1302 class FalseClosure: public OopClosure { | |
1303 public: | |
1304 void do_oop(oop* p) { | |
1305 guarantee(false, "Should be an empty set"); | |
1306 } | |
1307 }; | |
1308 | |
1309 // This closure is used to do concurrent marking from the roots | |
1310 // following the first checkpoint. | |
1311 class MarkFromRootsClosure: public BitMapClosure { | |
1312 CMSCollector* _collector; | |
1313 MemRegion _span; | |
1314 CMSBitMap* _bitMap; | |
1315 CMSBitMap* _mut; | |
1316 CMSMarkStack* _markStack; | |
1317 CMSMarkStack* _revisitStack; | |
1318 bool _yield; | |
1319 int _skipBits; | |
1320 HeapWord* _finger; | |
1321 HeapWord* _threshold; | |
1322 DEBUG_ONLY(bool _verifying;) | |
1323 | |
1324 public: | |
1325 MarkFromRootsClosure(CMSCollector* collector, MemRegion span, | |
1326 CMSBitMap* bitMap, | |
1327 CMSMarkStack* markStack, | |
1328 CMSMarkStack* revisitStack, | |
1329 bool should_yield, bool verifying = false); | |
1330 void do_bit(size_t offset); | |
1331 void reset(HeapWord* addr); | |
1332 inline void do_yield_check(); | |
1333 | |
1334 private: | |
1335 void scanOopsInOop(HeapWord* ptr); | |
1336 void do_yield_work(); | |
1337 }; | |
1338 | |
1339 // This closure is used to do concurrent multi-threaded | |
1340 // marking from the roots following the first checkpoint. | |
1341 // XXX This should really be a subclass of The serial version | |
1342 // above, but i have not had the time to refactor things cleanly. | |
1343 // That willbe done for Dolphin. | |
1344 class Par_MarkFromRootsClosure: public BitMapClosure { | |
1345 CMSCollector* _collector; | |
1346 MemRegion _whole_span; | |
1347 MemRegion _span; | |
1348 CMSBitMap* _bit_map; | |
1349 CMSBitMap* _mut; | |
1350 OopTaskQueue* _work_queue; | |
1351 CMSMarkStack* _overflow_stack; | |
1352 CMSMarkStack* _revisit_stack; | |
1353 bool _yield; | |
1354 int _skip_bits; | |
1355 HeapWord* _finger; | |
1356 HeapWord* _threshold; | |
1357 CMSConcMarkingTask* _task; | |
1358 public: | |
1359 Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, | |
1360 MemRegion span, | |
1361 CMSBitMap* bit_map, | |
1362 OopTaskQueue* work_queue, | |
1363 CMSMarkStack* overflow_stack, | |
1364 CMSMarkStack* revisit_stack, | |
1365 bool should_yield); | |
1366 void do_bit(size_t offset); | |
1367 inline void do_yield_check(); | |
1368 | |
1369 private: | |
1370 void scan_oops_in_oop(HeapWord* ptr); | |
1371 void do_yield_work(); | |
1372 bool get_work_from_overflow_stack(); | |
1373 }; | |
1374 | |
1375 // The following closures are used to do certain kinds of verification of | |
1376 // CMS marking. | |
1377 class PushAndMarkVerifyClosure: public OopClosure { | |
1378 CMSCollector* _collector; | |
1379 MemRegion _span; | |
1380 CMSBitMap* _verification_bm; | |
1381 CMSBitMap* _cms_bm; | |
1382 CMSMarkStack* _mark_stack; | |
1383 public: | |
1384 PushAndMarkVerifyClosure(CMSCollector* cms_collector, | |
1385 MemRegion span, | |
1386 CMSBitMap* verification_bm, | |
1387 CMSBitMap* cms_bm, | |
1388 CMSMarkStack* mark_stack); | |
1389 void do_oop(oop* p); | |
1390 // Deal with a stack overflow condition | |
1391 void handle_stack_overflow(HeapWord* lost); | |
1392 }; | |
1393 | |
1394 class MarkFromRootsVerifyClosure: public BitMapClosure { | |
1395 CMSCollector* _collector; | |
1396 MemRegion _span; | |
1397 CMSBitMap* _verification_bm; | |
1398 CMSBitMap* _cms_bm; | |
1399 CMSMarkStack* _mark_stack; | |
1400 HeapWord* _finger; | |
1401 PushAndMarkVerifyClosure _pam_verify_closure; | |
1402 public: | |
1403 MarkFromRootsVerifyClosure(CMSCollector* collector, MemRegion span, | |
1404 CMSBitMap* verification_bm, | |
1405 CMSBitMap* cms_bm, | |
1406 CMSMarkStack* mark_stack); | |
1407 void do_bit(size_t offset); | |
1408 void reset(HeapWord* addr); | |
1409 }; | |
1410 | |
1411 | |
1412 // This closure is used to check that a certain set of bits is | |
1413 // "empty" (i.e. the bit vector doesn't have any 1-bits). | |
1414 class FalseBitMapClosure: public BitMapClosure { | |
1415 public: | |
1416 void do_bit(size_t offset) { | |
1417 guarantee(false, "Should not have a 1 bit"); | |
1418 } | |
1419 }; | |
1420 | |
1421 // This closure is used during the second checkpointing phase | |
1422 // to rescan the marked objects on the dirty cards in the mod | |
1423 // union table and the card table proper. It's invoked via | |
1424 // MarkFromDirtyCardsClosure below. It uses either | |
1425 // [Par_]MarkRefsIntoAndScanClosure (Par_ in the parallel case) | |
1426 // declared in genOopClosures.hpp to accomplish some of its work. | |
1427 // In the parallel case the bitMap is shared, so access to | |
1428 // it needs to be suitably synchronized for updates by embedded | |
1429 // closures that update it; however, this closure itself only | |
1430 // reads the bit_map and because it is idempotent, is immune to | |
1431 // reading stale values. | |
1432 class ScanMarkedObjectsAgainClosure: public UpwardsObjectClosure { | |
1433 #ifdef ASSERT | |
1434 CMSCollector* _collector; | |
1435 MemRegion _span; | |
1436 union { | |
1437 CMSMarkStack* _mark_stack; | |
1438 OopTaskQueue* _work_queue; | |
1439 }; | |
1440 #endif // ASSERT | |
1441 bool _parallel; | |
1442 CMSBitMap* _bit_map; | |
1443 union { | |
1444 MarkRefsIntoAndScanClosure* _scan_closure; | |
1445 Par_MarkRefsIntoAndScanClosure* _par_scan_closure; | |
1446 }; | |
1447 | |
1448 public: | |
1449 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | |
1450 MemRegion span, | |
1451 ReferenceProcessor* rp, | |
1452 CMSBitMap* bit_map, | |
1453 CMSMarkStack* mark_stack, | |
1454 CMSMarkStack* revisit_stack, | |
1455 MarkRefsIntoAndScanClosure* cl): | |
1456 #ifdef ASSERT | |
1457 _collector(collector), | |
1458 _span(span), | |
1459 _mark_stack(mark_stack), | |
1460 #endif // ASSERT | |
1461 _parallel(false), | |
1462 _bit_map(bit_map), | |
1463 _scan_closure(cl) { } | |
1464 | |
1465 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | |
1466 MemRegion span, | |
1467 ReferenceProcessor* rp, | |
1468 CMSBitMap* bit_map, | |
1469 OopTaskQueue* work_queue, | |
1470 CMSMarkStack* revisit_stack, | |
1471 Par_MarkRefsIntoAndScanClosure* cl): | |
1472 #ifdef ASSERT | |
1473 _collector(collector), | |
1474 _span(span), | |
1475 _work_queue(work_queue), | |
1476 #endif // ASSERT | |
1477 _parallel(true), | |
1478 _bit_map(bit_map), | |
1479 _par_scan_closure(cl) { } | |
1480 | |
1481 void do_object(oop obj) { | |
1482 guarantee(false, "Call do_object_b(oop, MemRegion) instead"); | |
1483 } | |
1484 bool do_object_b(oop obj) { | |
1485 guarantee(false, "Call do_object_b(oop, MemRegion) form instead"); | |
1486 return false; | |
1487 } | |
1488 bool do_object_bm(oop p, MemRegion mr); | |
1489 }; | |
1490 | |
1491 // This closure is used during the second checkpointing phase | |
1492 // to rescan the marked objects on the dirty cards in the mod | |
1493 // union table and the card table proper. It invokes | |
1494 // ScanMarkedObjectsAgainClosure above to accomplish much of its work. | |
1495 // In the parallel case, the bit map is shared and requires | |
1496 // synchronized access. | |
1497 class MarkFromDirtyCardsClosure: public MemRegionClosure { | |
1498 CompactibleFreeListSpace* _space; | |
1499 ScanMarkedObjectsAgainClosure _scan_cl; | |
1500 size_t _num_dirty_cards; | |
1501 | |
1502 public: | |
1503 MarkFromDirtyCardsClosure(CMSCollector* collector, | |
1504 MemRegion span, | |
1505 CompactibleFreeListSpace* space, | |
1506 CMSBitMap* bit_map, | |
1507 CMSMarkStack* mark_stack, | |
1508 CMSMarkStack* revisit_stack, | |
1509 MarkRefsIntoAndScanClosure* cl): | |
1510 _space(space), | |
1511 _num_dirty_cards(0), | |
1512 _scan_cl(collector, span, collector->ref_processor(), bit_map, | |
1513 mark_stack, revisit_stack, cl) { } | |
1514 | |
1515 MarkFromDirtyCardsClosure(CMSCollector* collector, | |
1516 MemRegion span, | |
1517 CompactibleFreeListSpace* space, | |
1518 CMSBitMap* bit_map, | |
1519 OopTaskQueue* work_queue, | |
1520 CMSMarkStack* revisit_stack, | |
1521 Par_MarkRefsIntoAndScanClosure* cl): | |
1522 _space(space), | |
1523 _num_dirty_cards(0), | |
1524 _scan_cl(collector, span, collector->ref_processor(), bit_map, | |
1525 work_queue, revisit_stack, cl) { } | |
1526 | |
1527 void do_MemRegion(MemRegion mr); | |
1528 void set_space(CompactibleFreeListSpace* space) { _space = space; } | |
1529 size_t num_dirty_cards() { return _num_dirty_cards; } | |
1530 }; | |
1531 | |
1532 // This closure is used in the non-product build to check | |
1533 // that there are no MemRegions with a certain property. | |
1534 class FalseMemRegionClosure: public MemRegionClosure { | |
1535 void do_MemRegion(MemRegion mr) { | |
1536 guarantee(!mr.is_empty(), "Shouldn't be empty"); | |
1537 guarantee(false, "Should never be here"); | |
1538 } | |
1539 }; | |
1540 | |
1541 // This closure is used during the precleaning phase | |
1542 // to "carefully" rescan marked objects on dirty cards. | |
1543 // It uses MarkRefsIntoAndScanClosure declared in genOopClosures.hpp | |
1544 // to accomplish some of its work. | |
1545 class ScanMarkedObjectsAgainCarefullyClosure: public ObjectClosureCareful { | |
1546 CMSCollector* _collector; | |
1547 MemRegion _span; | |
1548 bool _yield; | |
1549 Mutex* _freelistLock; | |
1550 CMSBitMap* _bitMap; | |
1551 CMSMarkStack* _markStack; | |
1552 MarkRefsIntoAndScanClosure* _scanningClosure; | |
1553 | |
1554 public: | |
1555 ScanMarkedObjectsAgainCarefullyClosure(CMSCollector* collector, | |
1556 MemRegion span, | |
1557 CMSBitMap* bitMap, | |
1558 CMSMarkStack* markStack, | |
1559 CMSMarkStack* revisitStack, | |
1560 MarkRefsIntoAndScanClosure* cl, | |
1561 bool should_yield): | |
1562 _collector(collector), | |
1563 _span(span), | |
1564 _yield(should_yield), | |
1565 _bitMap(bitMap), | |
1566 _markStack(markStack), | |
1567 _scanningClosure(cl) { | |
1568 } | |
1569 | |
1570 void do_object(oop p) { | |
1571 guarantee(false, "call do_object_careful instead"); | |
1572 } | |
1573 | |
1574 size_t do_object_careful(oop p) { | |
1575 guarantee(false, "Unexpected caller"); | |
1576 return 0; | |
1577 } | |
1578 | |
1579 size_t do_object_careful_m(oop p, MemRegion mr); | |
1580 | |
1581 void setFreelistLock(Mutex* m) { | |
1582 _freelistLock = m; | |
1583 _scanningClosure->set_freelistLock(m); | |
1584 } | |
1585 | |
1586 private: | |
1587 inline bool do_yield_check(); | |
1588 | |
1589 void do_yield_work(); | |
1590 }; | |
1591 | |
1592 class SurvivorSpacePrecleanClosure: public ObjectClosureCareful { | |
1593 CMSCollector* _collector; | |
1594 MemRegion _span; | |
1595 bool _yield; | |
1596 CMSBitMap* _bit_map; | |
1597 CMSMarkStack* _mark_stack; | |
1598 PushAndMarkClosure* _scanning_closure; | |
1599 unsigned int _before_count; | |
1600 | |
1601 public: | |
1602 SurvivorSpacePrecleanClosure(CMSCollector* collector, | |
1603 MemRegion span, | |
1604 CMSBitMap* bit_map, | |
1605 CMSMarkStack* mark_stack, | |
1606 PushAndMarkClosure* cl, | |
1607 unsigned int before_count, | |
1608 bool should_yield): | |
1609 _collector(collector), | |
1610 _span(span), | |
1611 _yield(should_yield), | |
1612 _bit_map(bit_map), | |
1613 _mark_stack(mark_stack), | |
1614 _scanning_closure(cl), | |
1615 _before_count(before_count) | |
1616 { } | |
1617 | |
1618 void do_object(oop p) { | |
1619 guarantee(false, "call do_object_careful instead"); | |
1620 } | |
1621 | |
1622 size_t do_object_careful(oop p); | |
1623 | |
1624 size_t do_object_careful_m(oop p, MemRegion mr) { | |
1625 guarantee(false, "Unexpected caller"); | |
1626 return 0; | |
1627 } | |
1628 | |
1629 private: | |
1630 inline void do_yield_check(); | |
1631 void do_yield_work(); | |
1632 }; | |
1633 | |
1634 // This closure is used to accomplish the sweeping work | |
1635 // after the second checkpoint but before the concurrent reset | |
1636 // phase. | |
1637 // | |
1638 // Terminology | |
1639 // left hand chunk (LHC) - block of one or more chunks currently being | |
1640 // coalesced. The LHC is available for coalescing with a new chunk. | |
1641 // right hand chunk (RHC) - block that is currently being swept that is | |
1642 // free or garbage that can be coalesced with the LHC. | |
1643 // _inFreeRange is true if there is currently a LHC | |
1644 // _lastFreeRangeCoalesced is true if the LHC consists of more than one chunk. | |
1645 // _freeRangeInFreeLists is true if the LHC is in the free lists. | |
1646 // _freeFinger is the address of the current LHC | |
1647 class SweepClosure: public BlkClosureCareful { | |
1648 CMSCollector* _collector; // collector doing the work | |
1649 ConcurrentMarkSweepGeneration* _g; // Generation being swept | |
1650 CompactibleFreeListSpace* _sp; // Space being swept | |
1651 HeapWord* _limit; | |
1652 Mutex* _freelistLock; // Free list lock (in space) | |
1653 CMSBitMap* _bitMap; // Marking bit map (in | |
1654 // generation) | |
1655 bool _inFreeRange; // Indicates if we are in the | |
1656 // midst of a free run | |
1657 bool _freeRangeInFreeLists; | |
1658 // Often, we have just found | |
1659 // a free chunk and started | |
1660 // a new free range; we do not | |
1661 // eagerly remove this chunk from | |
1662 // the free lists unless there is | |
1663 // a possibility of coalescing. | |
1664 // When true, this flag indicates | |
1665 // that the _freeFinger below | |
1666 // points to a potentially free chunk | |
1667 // that may still be in the free lists | |
1668 bool _lastFreeRangeCoalesced; | |
1669 // free range contains chunks | |
1670 // coalesced | |
1671 bool _yield; | |
1672 // Whether sweeping should be | |
1673 // done with yields. For instance | |
1674 // when done by the foreground | |
1675 // collector we shouldn't yield. | |
1676 HeapWord* _freeFinger; // When _inFreeRange is set, the | |
1677 // pointer to the "left hand | |
1678 // chunk" | |
1679 size_t _freeRangeSize; | |
1680 // When _inFreeRange is set, this | |
1681 // indicates the accumulated size | |
1682 // of the "left hand chunk" | |
1683 NOT_PRODUCT( | |
1684 size_t _numObjectsFreed; | |
1685 size_t _numWordsFreed; | |
1686 size_t _numObjectsLive; | |
1687 size_t _numWordsLive; | |
1688 size_t _numObjectsAlreadyFree; | |
1689 size_t _numWordsAlreadyFree; | |
1690 FreeChunk* _last_fc; | |
1691 ) | |
1692 private: | |
1693 // Code that is common to a free chunk or garbage when | |
1694 // encountered during sweeping. | |
1695 void doPostIsFreeOrGarbageChunk(FreeChunk *fc, | |
1696 size_t chunkSize); | |
1697 // Process a free chunk during sweeping. | |
1698 void doAlreadyFreeChunk(FreeChunk *fc); | |
1699 // Process a garbage chunk during sweeping. | |
1700 size_t doGarbageChunk(FreeChunk *fc); | |
1701 // Process a live chunk during sweeping. | |
1702 size_t doLiveChunk(FreeChunk* fc); | |
1703 | |
1704 // Accessors. | |
1705 HeapWord* freeFinger() const { return _freeFinger; } | |
1706 void set_freeFinger(HeapWord* v) { _freeFinger = v; } | |
1707 size_t freeRangeSize() const { return _freeRangeSize; } | |
1708 void set_freeRangeSize(size_t v) { _freeRangeSize = v; } | |
1709 bool inFreeRange() const { return _inFreeRange; } | |
1710 void set_inFreeRange(bool v) { _inFreeRange = v; } | |
1711 bool lastFreeRangeCoalesced() const { return _lastFreeRangeCoalesced; } | |
1712 void set_lastFreeRangeCoalesced(bool v) { _lastFreeRangeCoalesced = v; } | |
1713 bool freeRangeInFreeLists() const { return _freeRangeInFreeLists; } | |
1714 void set_freeRangeInFreeLists(bool v) { _freeRangeInFreeLists = v; } | |
1715 | |
1716 // Initialize a free range. | |
1717 void initialize_free_range(HeapWord* freeFinger, bool freeRangeInFreeLists); | |
1718 // Return this chunk to the free lists. | |
1719 void flushCurFreeChunk(HeapWord* chunk, size_t size); | |
1720 | |
1721 // Check if we should yield and do so when necessary. | |
1722 inline void do_yield_check(HeapWord* addr); | |
1723 | |
1724 // Yield | |
1725 void do_yield_work(HeapWord* addr); | |
1726 | |
1727 // Debugging/Printing | |
1728 void record_free_block_coalesced(FreeChunk* fc) const PRODUCT_RETURN; | |
1729 | |
1730 public: | |
1731 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g, | |
1732 CMSBitMap* bitMap, bool should_yield); | |
1733 ~SweepClosure(); | |
1734 | |
1735 size_t do_blk_careful(HeapWord* addr); | |
1736 }; | |
1737 | |
1738 // Closures related to weak references processing | |
1739 | |
1740 // During CMS' weak reference processing, this is a | |
1741 // work-routine/closure used to complete transitive | |
1742 // marking of objects as live after a certain point | |
1743 // in which an initial set has been completely accumulated. | |
1744 class CMSDrainMarkingStackClosure: public VoidClosure { | |
1745 CMSCollector* _collector; | |
1746 MemRegion _span; | |
1747 CMSMarkStack* _mark_stack; | |
1748 CMSBitMap* _bit_map; | |
1749 CMSKeepAliveClosure* _keep_alive; | |
1750 public: | |
1751 CMSDrainMarkingStackClosure(CMSCollector* collector, MemRegion span, | |
1752 CMSBitMap* bit_map, CMSMarkStack* mark_stack, | |
1753 CMSKeepAliveClosure* keep_alive): | |
1754 _collector(collector), | |
1755 _span(span), | |
1756 _bit_map(bit_map), | |
1757 _mark_stack(mark_stack), | |
1758 _keep_alive(keep_alive) { } | |
1759 | |
1760 void do_void(); | |
1761 }; | |
1762 | |
1763 // A parallel version of CMSDrainMarkingStackClosure above. | |
1764 class CMSParDrainMarkingStackClosure: public VoidClosure { | |
1765 CMSCollector* _collector; | |
1766 MemRegion _span; | |
1767 OopTaskQueue* _work_queue; | |
1768 CMSBitMap* _bit_map; | |
1769 CMSInnerParMarkAndPushClosure _mark_and_push; | |
1770 | |
1771 public: | |
1772 CMSParDrainMarkingStackClosure(CMSCollector* collector, | |
1773 MemRegion span, CMSBitMap* bit_map, | |
1774 OopTaskQueue* work_queue): | |
1775 _collector(collector), | |
1776 _span(span), | |
1777 _bit_map(bit_map), | |
1778 _work_queue(work_queue), | |
1779 _mark_and_push(collector, span, bit_map, work_queue) { } | |
1780 | |
1781 public: | |
1782 void trim_queue(uint max); | |
1783 void do_void(); | |
1784 }; | |
1785 | |
1786 // Allow yielding or short-circuiting of reference list | |
1787 // prelceaning work. | |
1788 class CMSPrecleanRefsYieldClosure: public YieldClosure { | |
1789 CMSCollector* _collector; | |
1790 void do_yield_work(); | |
1791 public: | |
1792 CMSPrecleanRefsYieldClosure(CMSCollector* collector): | |
1793 _collector(collector) {} | |
1794 virtual bool should_return(); | |
1795 }; | |
1796 | |
1797 | |
1798 // Convenience class that locks free list locks for given CMS collector | |
1799 class FreelistLocker: public StackObj { | |
1800 private: | |
1801 CMSCollector* _collector; | |
1802 public: | |
1803 FreelistLocker(CMSCollector* collector): | |
1804 _collector(collector) { | |
1805 _collector->getFreelistLocks(); | |
1806 } | |
1807 | |
1808 ~FreelistLocker() { | |
1809 _collector->releaseFreelistLocks(); | |
1810 } | |
1811 }; | |
1812 | |
1813 // Mark all dead objects in a given space. | |
1814 class MarkDeadObjectsClosure: public BlkClosure { | |
1815 const CMSCollector* _collector; | |
1816 const CompactibleFreeListSpace* _sp; | |
1817 CMSBitMap* _live_bit_map; | |
1818 CMSBitMap* _dead_bit_map; | |
1819 public: | |
1820 MarkDeadObjectsClosure(const CMSCollector* collector, | |
1821 const CompactibleFreeListSpace* sp, | |
1822 CMSBitMap *live_bit_map, | |
1823 CMSBitMap *dead_bit_map) : | |
1824 _collector(collector), | |
1825 _sp(sp), | |
1826 _live_bit_map(live_bit_map), | |
1827 _dead_bit_map(dead_bit_map) {} | |
1828 size_t do_blk(HeapWord* addr); | |
1829 }; |