Mon, 16 Aug 2010 15:58:42 -0700
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
Summary: GC workers now recognize an intermediate transient state of blocks which are allocated but have not yet completed initialization. blk_start() calls do not attempt to determine the size of a block in the transient state, rather waiting for the block to become initialized so that it is safe to query its size. Audited and ensured the order of initialization of object fields (klass, free bit and size) to respect block state transition protocol. Also included some new assertion checking code enabled in debug mode.
Reviewed-by: chrisphi, johnc, poonam
1 /*
2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 // Classes in support of keeping track of promotions into a non-Contiguous
26 // space, in this case a CompactibleFreeListSpace.
28 // Forward declarations
29 class CompactibleFreeListSpace;
30 class BlkClosure;
31 class BlkClosureCareful;
32 class UpwardsObjectClosure;
33 class ObjectClosureCareful;
34 class Klass;
36 class LinearAllocBlock VALUE_OBJ_CLASS_SPEC {
37 public:
38 LinearAllocBlock() : _ptr(0), _word_size(0), _refillSize(0),
39 _allocation_size_limit(0) {}
40 void set(HeapWord* ptr, size_t word_size, size_t refill_size,
41 size_t allocation_size_limit) {
42 _ptr = ptr;
43 _word_size = word_size;
44 _refillSize = refill_size;
45 _allocation_size_limit = allocation_size_limit;
46 }
47 HeapWord* _ptr;
48 size_t _word_size;
49 size_t _refillSize;
50 size_t _allocation_size_limit; // largest size that will be allocated
52 void print_on(outputStream* st) const;
53 };
55 // Concrete subclass of CompactibleSpace that implements
56 // a free list space, such as used in the concurrent mark sweep
57 // generation.
59 class CompactibleFreeListSpace: public CompactibleSpace {
60 friend class VMStructs;
61 friend class ConcurrentMarkSweepGeneration;
62 friend class ASConcurrentMarkSweepGeneration;
63 friend class CMSCollector;
64 friend class CMSPermGenGen;
65 // Local alloc buffer for promotion into this space.
66 friend class CFLS_LAB;
68 // "Size" of chunks of work (executed during parallel remark phases
69 // of CMS collection); this probably belongs in CMSCollector, although
70 // it's cached here because it's used in
71 // initialize_sequential_subtasks_for_rescan() which modifies
72 // par_seq_tasks which also lives in Space. XXX
73 const size_t _rescan_task_size;
74 const size_t _marking_task_size;
76 // Yet another sequential tasks done structure. This supports
77 // CMS GC, where we have threads dynamically
78 // claiming sub-tasks from a larger parallel task.
79 SequentialSubTasksDone _conc_par_seq_tasks;
81 BlockOffsetArrayNonContigSpace _bt;
83 CMSCollector* _collector;
84 ConcurrentMarkSweepGeneration* _gen;
86 // Data structures for free blocks (used during allocation/sweeping)
88 // Allocation is done linearly from two different blocks depending on
89 // whether the request is small or large, in an effort to reduce
90 // fragmentation. We assume that any locking for allocation is done
91 // by the containing generation. Thus, none of the methods in this
92 // space are re-entrant.
93 enum SomeConstants {
94 SmallForLinearAlloc = 16, // size < this then use _sLAB
95 SmallForDictionary = 257, // size < this then use _indexedFreeList
96 IndexSetSize = SmallForDictionary // keep this odd-sized
97 };
98 static int IndexSetStart;
99 static int IndexSetStride;
101 private:
102 enum FitStrategyOptions {
103 FreeBlockStrategyNone = 0,
104 FreeBlockBestFitFirst
105 };
107 PromotionInfo _promoInfo;
109 // helps to impose a global total order on freelistLock ranks;
110 // assumes that CFLSpace's are allocated in global total order
111 static int _lockRank;
113 // a lock protecting the free lists and free blocks;
114 // mutable because of ubiquity of locking even for otherwise const methods
115 mutable Mutex _freelistLock;
116 // locking verifier convenience function
117 void assert_locked() const PRODUCT_RETURN;
118 void assert_locked(const Mutex* lock) const PRODUCT_RETURN;
120 // Linear allocation blocks
121 LinearAllocBlock _smallLinearAllocBlock;
123 FreeBlockDictionary::DictionaryChoice _dictionaryChoice;
124 FreeBlockDictionary* _dictionary; // ptr to dictionary for large size blocks
126 FreeList _indexedFreeList[IndexSetSize];
127 // indexed array for small size blocks
128 // allocation stategy
129 bool _fitStrategy; // Use best fit strategy.
130 bool _adaptive_freelists; // Use adaptive freelists
132 // This is an address close to the largest free chunk in the heap.
133 // It is currently assumed to be at the end of the heap. Free
134 // chunks with addresses greater than nearLargestChunk are coalesced
135 // in an effort to maintain a large chunk at the end of the heap.
136 HeapWord* _nearLargestChunk;
138 // Used to keep track of limit of sweep for the space
139 HeapWord* _sweep_limit;
141 // Support for compacting cms
142 HeapWord* cross_threshold(HeapWord* start, HeapWord* end);
143 HeapWord* forward(oop q, size_t size, CompactPoint* cp, HeapWord* compact_top);
145 // Initialization helpers.
146 void initializeIndexedFreeListArray();
148 // Extra stuff to manage promotion parallelism.
150 // a lock protecting the dictionary during par promotion allocation.
151 mutable Mutex _parDictionaryAllocLock;
152 Mutex* parDictionaryAllocLock() const { return &_parDictionaryAllocLock; }
154 // Locks protecting the exact lists during par promotion allocation.
155 Mutex* _indexedFreeListParLocks[IndexSetSize];
157 // Attempt to obtain up to "n" blocks of the size "word_sz" (which is
158 // required to be smaller than "IndexSetSize".) If successful,
159 // adds them to "fl", which is required to be an empty free list.
160 // If the count of "fl" is negative, it's absolute value indicates a
161 // number of free chunks that had been previously "borrowed" from global
162 // list of size "word_sz", and must now be decremented.
163 void par_get_chunk_of_blocks(size_t word_sz, size_t n, FreeList* fl);
165 // Allocation helper functions
166 // Allocate using a strategy that takes from the indexed free lists
167 // first. This allocation strategy assumes a companion sweeping
168 // strategy that attempts to keep the needed number of chunks in each
169 // indexed free lists.
170 HeapWord* allocate_adaptive_freelists(size_t size);
171 // Allocate from the linear allocation buffers first. This allocation
172 // strategy assumes maximal coalescing can maintain chunks large enough
173 // to be used as linear allocation buffers.
174 HeapWord* allocate_non_adaptive_freelists(size_t size);
176 // Gets a chunk from the linear allocation block (LinAB). If there
177 // is not enough space in the LinAB, refills it.
178 HeapWord* getChunkFromLinearAllocBlock(LinearAllocBlock* blk, size_t size);
179 HeapWord* getChunkFromSmallLinearAllocBlock(size_t size);
180 // Get a chunk from the space remaining in the linear allocation block. Do
181 // not attempt to refill if the space is not available, return NULL. Do the
182 // repairs on the linear allocation block as appropriate.
183 HeapWord* getChunkFromLinearAllocBlockRemainder(LinearAllocBlock* blk, size_t size);
184 inline HeapWord* getChunkFromSmallLinearAllocBlockRemainder(size_t size);
186 // Helper function for getChunkFromIndexedFreeList.
187 // Replenish the indexed free list for this "size". Do not take from an
188 // underpopulated size.
189 FreeChunk* getChunkFromIndexedFreeListHelper(size_t size, bool replenish = true);
191 // Get a chunk from the indexed free list. If the indexed free list
192 // does not have a free chunk, try to replenish the indexed free list
193 // then get the free chunk from the replenished indexed free list.
194 inline FreeChunk* getChunkFromIndexedFreeList(size_t size);
196 // The returned chunk may be larger than requested (or null).
197 FreeChunk* getChunkFromDictionary(size_t size);
198 // The returned chunk is the exact size requested (or null).
199 FreeChunk* getChunkFromDictionaryExact(size_t size);
201 // Find a chunk in the indexed free list that is the best
202 // fit for size "numWords".
203 FreeChunk* bestFitSmall(size_t numWords);
204 // For free list "fl" of chunks of size > numWords,
205 // remove a chunk, split off a chunk of size numWords
206 // and return it. The split off remainder is returned to
207 // the free lists. The old name for getFromListGreater
208 // was lookInListGreater.
209 FreeChunk* getFromListGreater(FreeList* fl, size_t numWords);
210 // Get a chunk in the indexed free list or dictionary,
211 // by considering a larger chunk and splitting it.
212 FreeChunk* getChunkFromGreater(size_t numWords);
213 // Verify that the given chunk is in the indexed free lists.
214 bool verifyChunkInIndexedFreeLists(FreeChunk* fc) const;
215 // Remove the specified chunk from the indexed free lists.
216 void removeChunkFromIndexedFreeList(FreeChunk* fc);
217 // Remove the specified chunk from the dictionary.
218 void removeChunkFromDictionary(FreeChunk* fc);
219 // Split a free chunk into a smaller free chunk of size "new_size".
220 // Return the smaller free chunk and return the remainder to the
221 // free lists.
222 FreeChunk* splitChunkAndReturnRemainder(FreeChunk* chunk, size_t new_size);
223 // Add a chunk to the free lists.
224 void addChunkToFreeLists(HeapWord* chunk, size_t size);
225 // Add a chunk to the free lists, preferring to suffix it
226 // to the last free chunk at end of space if possible, and
227 // updating the block census stats as well as block offset table.
228 // Take any locks as appropriate if we are multithreaded.
229 void addChunkToFreeListsAtEndRecordingStats(HeapWord* chunk, size_t size);
230 // Add a free chunk to the indexed free lists.
231 void returnChunkToFreeList(FreeChunk* chunk);
232 // Add a free chunk to the dictionary.
233 void returnChunkToDictionary(FreeChunk* chunk);
235 // Functions for maintaining the linear allocation buffers (LinAB).
236 // Repairing a linear allocation block refers to operations
237 // performed on the remainder of a LinAB after an allocation
238 // has been made from it.
239 void repairLinearAllocationBlocks();
240 void repairLinearAllocBlock(LinearAllocBlock* blk);
241 void refillLinearAllocBlock(LinearAllocBlock* blk);
242 void refillLinearAllocBlockIfNeeded(LinearAllocBlock* blk);
243 void refillLinearAllocBlocksIfNeeded();
245 void verify_objects_initialized() const;
247 // Statistics reporting helper functions
248 void reportFreeListStatistics() const;
249 void reportIndexedFreeListStatistics() const;
250 size_t maxChunkSizeInIndexedFreeLists() const;
251 size_t numFreeBlocksInIndexedFreeLists() const;
252 // Accessor
253 HeapWord* unallocated_block() const {
254 if (BlockOffsetArrayUseUnallocatedBlock) {
255 HeapWord* ub = _bt.unallocated_block();
256 assert(ub >= bottom() &&
257 ub <= end(), "space invariant");
258 return ub;
259 } else {
260 return end();
261 }
262 }
263 void freed(HeapWord* start, size_t size) {
264 _bt.freed(start, size);
265 }
267 protected:
268 // reset the indexed free list to its initial empty condition.
269 void resetIndexedFreeListArray();
270 // reset to an initial state with a single free block described
271 // by the MemRegion parameter.
272 void reset(MemRegion mr);
273 // Return the total number of words in the indexed free lists.
274 size_t totalSizeInIndexedFreeLists() const;
276 public:
277 // Constructor...
278 CompactibleFreeListSpace(BlockOffsetSharedArray* bs, MemRegion mr,
279 bool use_adaptive_freelists,
280 FreeBlockDictionary::DictionaryChoice);
281 // accessors
282 bool bestFitFirst() { return _fitStrategy == FreeBlockBestFitFirst; }
283 FreeBlockDictionary* dictionary() const { return _dictionary; }
284 HeapWord* nearLargestChunk() const { return _nearLargestChunk; }
285 void set_nearLargestChunk(HeapWord* v) { _nearLargestChunk = v; }
287 // Set CMS global values
288 static void set_cms_values();
290 // Return the free chunk at the end of the space. If no such
291 // chunk exists, return NULL.
292 FreeChunk* find_chunk_at_end();
294 bool adaptive_freelists() const { return _adaptive_freelists; }
296 void set_collector(CMSCollector* collector) { _collector = collector; }
298 // Support for parallelization of rescan and marking
299 const size_t rescan_task_size() const { return _rescan_task_size; }
300 const size_t marking_task_size() const { return _marking_task_size; }
301 SequentialSubTasksDone* conc_par_seq_tasks() {return &_conc_par_seq_tasks; }
302 void initialize_sequential_subtasks_for_rescan(int n_threads);
303 void initialize_sequential_subtasks_for_marking(int n_threads,
304 HeapWord* low = NULL);
306 // Space enquiries
307 size_t used() const;
308 size_t free() const;
309 size_t max_alloc_in_words() const;
310 // XXX: should have a less conservative used_region() than that of
311 // Space; we could consider keeping track of highest allocated
312 // address and correcting that at each sweep, as the sweeper
313 // goes through the entire allocated part of the generation. We
314 // could also use that information to keep the sweeper from
315 // sweeping more than is necessary. The allocator and sweeper will
316 // of course need to synchronize on this, since the sweeper will
317 // try to bump down the address and the allocator will try to bump it up.
318 // For now, however, we'll just use the default used_region()
319 // which overestimates the region by returning the entire
320 // committed region (this is safe, but inefficient).
322 // Returns a subregion of the space containing all the objects in
323 // the space.
324 MemRegion used_region() const {
325 return MemRegion(bottom(),
326 BlockOffsetArrayUseUnallocatedBlock ?
327 unallocated_block() : end());
328 }
330 // This is needed because the default implementation uses block_start()
331 // which can;t be used at certain times (for example phase 3 of mark-sweep).
332 // A better fix is to change the assertions in phase 3 of mark-sweep to
333 // use is_in_reserved(), but that is deferred since the is_in() assertions
334 // are buried through several layers of callers and are used elsewhere
335 // as well.
336 bool is_in(const void* p) const {
337 return used_region().contains(p);
338 }
340 virtual bool is_free_block(const HeapWord* p) const;
342 // Resizing support
343 void set_end(HeapWord* value); // override
345 // mutual exclusion support
346 Mutex* freelistLock() const { return &_freelistLock; }
348 // Iteration support
349 void oop_iterate(MemRegion mr, OopClosure* cl);
350 void oop_iterate(OopClosure* cl);
352 void object_iterate(ObjectClosure* blk);
353 // Apply the closure to each object in the space whose references
354 // point to objects in the heap. The usage of CompactibleFreeListSpace
355 // by the ConcurrentMarkSweepGeneration for concurrent GC's allows
356 // objects in the space with references to objects that are no longer
357 // valid. For example, an object may reference another object
358 // that has already been sweep up (collected). This method uses
359 // obj_is_alive() to determine whether it is safe to iterate of
360 // an object.
361 void safe_object_iterate(ObjectClosure* blk);
362 void object_iterate_mem(MemRegion mr, UpwardsObjectClosure* cl);
364 // Requires that "mr" be entirely within the space.
365 // Apply "cl->do_object" to all objects that intersect with "mr".
366 // If the iteration encounters an unparseable portion of the region,
367 // terminate the iteration and return the address of the start of the
368 // subregion that isn't done. Return of "NULL" indicates that the
369 // interation completed.
370 virtual HeapWord*
371 object_iterate_careful_m(MemRegion mr,
372 ObjectClosureCareful* cl);
373 virtual HeapWord*
374 object_iterate_careful(ObjectClosureCareful* cl);
376 // Override: provides a DCTO_CL specific to this kind of space.
377 DirtyCardToOopClosure* new_dcto_cl(OopClosure* cl,
378 CardTableModRefBS::PrecisionStyle precision,
379 HeapWord* boundary);
381 void blk_iterate(BlkClosure* cl);
382 void blk_iterate_careful(BlkClosureCareful* cl);
383 HeapWord* block_start_const(const void* p) const;
384 HeapWord* block_start_careful(const void* p) const;
385 size_t block_size(const HeapWord* p) const;
386 size_t block_size_no_stall(HeapWord* p, const CMSCollector* c) const;
387 bool block_is_obj(const HeapWord* p) const;
388 bool obj_is_alive(const HeapWord* p) const;
389 size_t block_size_nopar(const HeapWord* p) const;
390 bool block_is_obj_nopar(const HeapWord* p) const;
392 // iteration support for promotion
393 void save_marks();
394 bool no_allocs_since_save_marks();
395 void object_iterate_since_last_GC(ObjectClosure* cl);
397 // iteration support for sweeping
398 void save_sweep_limit() {
399 _sweep_limit = BlockOffsetArrayUseUnallocatedBlock ?
400 unallocated_block() : end();
401 }
402 NOT_PRODUCT(
403 void clear_sweep_limit() { _sweep_limit = NULL; }
404 )
405 HeapWord* sweep_limit() { return _sweep_limit; }
407 // Apply "blk->do_oop" to the addresses of all reference fields in objects
408 // promoted into this generation since the most recent save_marks() call.
409 // Fields in objects allocated by applications of the closure
410 // *are* included in the iteration. Thus, when the iteration completes
411 // there should be no further such objects remaining.
412 #define CFLS_OOP_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \
413 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* blk);
414 ALL_SINCE_SAVE_MARKS_CLOSURES(CFLS_OOP_SINCE_SAVE_MARKS_DECL)
415 #undef CFLS_OOP_SINCE_SAVE_MARKS_DECL
417 // Allocation support
418 HeapWord* allocate(size_t size);
419 HeapWord* par_allocate(size_t size);
421 oop promote(oop obj, size_t obj_size);
422 void gc_prologue();
423 void gc_epilogue();
425 // This call is used by a containing CMS generation / collector
426 // to inform the CFLS space that a sweep has been completed
427 // and that the space can do any related house-keeping functions.
428 void sweep_completed();
430 // For an object in this space, the mark-word's two
431 // LSB's having the value [11] indicates that it has been
432 // promoted since the most recent call to save_marks() on
433 // this generation and has not subsequently been iterated
434 // over (using oop_since_save_marks_iterate() above).
435 // This property holds only for single-threaded collections,
436 // and is typically used for Cheney scans; for MT scavenges,
437 // the property holds for all objects promoted during that
438 // scavenge for the duration of the scavenge and is used
439 // by card-scanning to avoid scanning objects (being) promoted
440 // during that scavenge.
441 bool obj_allocated_since_save_marks(const oop obj) const {
442 assert(is_in_reserved(obj), "Wrong space?");
443 return ((PromotedObject*)obj)->hasPromotedMark();
444 }
446 // A worst-case estimate of the space required (in HeapWords) to expand the
447 // heap when promoting an obj of size obj_size.
448 size_t expansionSpaceRequired(size_t obj_size) const;
450 FreeChunk* allocateScratch(size_t size);
452 // returns true if either the small or large linear allocation buffer is empty.
453 bool linearAllocationWouldFail() const;
455 // Adjust the chunk for the minimum size. This version is called in
456 // most cases in CompactibleFreeListSpace methods.
457 inline static size_t adjustObjectSize(size_t size) {
458 return (size_t) align_object_size(MAX2(size, (size_t)MinChunkSize));
459 }
460 // This is a virtual version of adjustObjectSize() that is called
461 // only occasionally when the compaction space changes and the type
462 // of the new compaction space is is only known to be CompactibleSpace.
463 size_t adjust_object_size_v(size_t size) const {
464 return adjustObjectSize(size);
465 }
466 // Minimum size of a free block.
467 virtual size_t minimum_free_block_size() const { return MinChunkSize; }
468 void removeFreeChunkFromFreeLists(FreeChunk* chunk);
469 void addChunkAndRepairOffsetTable(HeapWord* chunk, size_t size,
470 bool coalesced);
472 // Support for decisions regarding concurrent collection policy
473 bool should_concurrent_collect() const;
475 // Support for compaction
476 void prepare_for_compaction(CompactPoint* cp);
477 void adjust_pointers();
478 void compact();
479 // reset the space to reflect the fact that a compaction of the
480 // space has been done.
481 virtual void reset_after_compaction();
483 // Debugging support
484 void print() const;
485 void print_on(outputStream* st) const;
486 void prepare_for_verify();
487 void verify(bool allow_dirty) const;
488 void verifyFreeLists() const PRODUCT_RETURN;
489 void verifyIndexedFreeLists() const;
490 void verifyIndexedFreeList(size_t size) const;
491 // verify that the given chunk is in the free lists.
492 bool verifyChunkInFreeLists(FreeChunk* fc) const;
493 // Do some basic checks on the the free lists.
494 void checkFreeListConsistency() const PRODUCT_RETURN;
496 // Printing support
497 void dump_at_safepoint_with_locks(CMSCollector* c, outputStream* st);
498 void print_indexed_free_lists(outputStream* st) const;
499 void print_dictionary_free_lists(outputStream* st) const;
500 void print_promo_info_blocks(outputStream* st) const;
502 NOT_PRODUCT (
503 void initializeIndexedFreeListArrayReturnedBytes();
504 size_t sumIndexedFreeListArrayReturnedBytes();
505 // Return the total number of chunks in the indexed free lists.
506 size_t totalCountInIndexedFreeLists() const;
507 // Return the total numberof chunks in the space.
508 size_t totalCount();
509 )
511 // The census consists of counts of the quantities such as
512 // the current count of the free chunks, number of chunks
513 // created as a result of the split of a larger chunk or
514 // coalescing of smaller chucks, etc. The counts in the
515 // census is used to make decisions on splitting and
516 // coalescing of chunks during the sweep of garbage.
518 // Print the statistics for the free lists.
519 void printFLCensus(size_t sweep_count) const;
521 // Statistics functions
522 // Initialize census for lists before the sweep.
523 void beginSweepFLCensus(float inter_sweep_current,
524 float inter_sweep_estimate,
525 float intra_sweep_estimate);
526 // Set the surplus for each of the free lists.
527 void setFLSurplus();
528 // Set the hint for each of the free lists.
529 void setFLHints();
530 // Clear the census for each of the free lists.
531 void clearFLCensus();
532 // Perform functions for the census after the end of the sweep.
533 void endSweepFLCensus(size_t sweep_count);
534 // Return true if the count of free chunks is greater
535 // than the desired number of free chunks.
536 bool coalOverPopulated(size_t size);
538 // Record (for each size):
539 //
540 // split-births = #chunks added due to splits in (prev-sweep-end,
541 // this-sweep-start)
542 // split-deaths = #chunks removed for splits in (prev-sweep-end,
543 // this-sweep-start)
544 // num-curr = #chunks at start of this sweep
545 // num-prev = #chunks at end of previous sweep
546 //
547 // The above are quantities that are measured. Now define:
548 //
549 // num-desired := num-prev + split-births - split-deaths - num-curr
550 //
551 // Roughly, num-prev + split-births is the supply,
552 // split-deaths is demand due to other sizes
553 // and num-curr is what we have left.
554 //
555 // Thus, num-desired is roughly speaking the "legitimate demand"
556 // for blocks of this size and what we are striving to reach at the
557 // end of the current sweep.
558 //
559 // For a given list, let num-len be its current population.
560 // Define, for a free list of a given size:
561 //
562 // coal-overpopulated := num-len >= num-desired * coal-surplus
563 // (coal-surplus is set to 1.05, i.e. we allow a little slop when
564 // coalescing -- we do not coalesce unless we think that the current
565 // supply has exceeded the estimated demand by more than 5%).
566 //
567 // For the set of sizes in the binary tree, which is neither dense nor
568 // closed, it may be the case that for a particular size we have never
569 // had, or do not now have, or did not have at the previous sweep,
570 // chunks of that size. We need to extend the definition of
571 // coal-overpopulated to such sizes as well:
572 //
573 // For a chunk in/not in the binary tree, extend coal-overpopulated
574 // defined above to include all sizes as follows:
575 //
576 // . a size that is non-existent is coal-overpopulated
577 // . a size that has a num-desired <= 0 as defined above is
578 // coal-overpopulated.
579 //
580 // Also define, for a chunk heap-offset C and mountain heap-offset M:
581 //
582 // close-to-mountain := C >= 0.99 * M
583 //
584 // Now, the coalescing strategy is:
585 //
586 // Coalesce left-hand chunk with right-hand chunk if and
587 // only if:
588 //
589 // EITHER
590 // . left-hand chunk is of a size that is coal-overpopulated
591 // OR
592 // . right-hand chunk is close-to-mountain
593 void smallCoalBirth(size_t size);
594 void smallCoalDeath(size_t size);
595 void coalBirth(size_t size);
596 void coalDeath(size_t size);
597 void smallSplitBirth(size_t size);
598 void smallSplitDeath(size_t size);
599 void splitBirth(size_t size);
600 void splitDeath(size_t size);
601 void split(size_t from, size_t to1);
603 double flsFrag() const;
604 };
606 // A parallel-GC-thread-local allocation buffer for allocation into a
607 // CompactibleFreeListSpace.
608 class CFLS_LAB : public CHeapObj {
609 // The space that this buffer allocates into.
610 CompactibleFreeListSpace* _cfls;
612 // Our local free lists.
613 FreeList _indexedFreeList[CompactibleFreeListSpace::IndexSetSize];
615 // Initialized from a command-line arg.
617 // Allocation statistics in support of dynamic adjustment of
618 // #blocks to claim per get_from_global_pool() call below.
619 static AdaptiveWeightedAverage
620 _blocks_to_claim [CompactibleFreeListSpace::IndexSetSize];
621 static size_t _global_num_blocks [CompactibleFreeListSpace::IndexSetSize];
622 static int _global_num_workers[CompactibleFreeListSpace::IndexSetSize];
623 size_t _num_blocks [CompactibleFreeListSpace::IndexSetSize];
625 // Internal work method
626 void get_from_global_pool(size_t word_sz, FreeList* fl);
628 public:
629 CFLS_LAB(CompactibleFreeListSpace* cfls);
631 // Allocate and return a block of the given size, or else return NULL.
632 HeapWord* alloc(size_t word_sz);
634 // Return any unused portions of the buffer to the global pool.
635 void retire(int tid);
637 // Dynamic OldPLABSize sizing
638 static void compute_desired_plab_size();
639 // When the settings are modified from default static initialization
640 static void modify_initialization(size_t n, unsigned wt);
641 };
643 size_t PromotionInfo::refillSize() const {
644 const size_t CMSSpoolBlockSize = 256;
645 const size_t sz = heap_word_size(sizeof(SpoolBlock) + sizeof(markOop)
646 * CMSSpoolBlockSize);
647 return CompactibleFreeListSpace::adjustObjectSize(sz);
648 }