175 // Linear allocation blocks 176 LinearAllocBlock _smallLinearAllocBlock; 177 178 AFLBinaryTreeDictionary* _dictionary; // Pointer to dictionary for large size blocks 179 180 // Indexed array for small size blocks 181 AdaptiveFreeList<FreeChunk> _indexedFreeList[IndexSetSize]; 182 183 // Allocation strategy 184 bool _fitStrategy; // Use best fit strategy 185 186 // This is an address close to the largest free chunk in the heap. 187 // It is currently assumed to be at the end of the heap. Free 188 // chunks with addresses greater than nearLargestChunk are coalesced 189 // in an effort to maintain a large chunk at the end of the heap. 190 HeapWord* _nearLargestChunk; 191 192 // Used to keep track of limit of sweep for the space 193 HeapWord* _sweep_limit; 194 195 // Used to make the young collector update the mod union table 196 MemRegionClosure* _preconsumptionDirtyCardClosure; 197 198 // Support for compacting cms 199 HeapWord* cross_threshold(HeapWord* start, HeapWord* end); 200 HeapWord* forward(oop q, size_t size, CompactPoint* cp, HeapWord* compact_top); 201 202 // Initialization helpers. 203 void initializeIndexedFreeListArray(); 204 205 // Extra stuff to manage promotion parallelism. 206 207 // A lock protecting the dictionary during par promotion allocation. 208 mutable Mutex _parDictionaryAllocLock; 209 Mutex* parDictionaryAllocLock() const { return &_parDictionaryAllocLock; } 210 211 // Locks protecting the exact lists during par promotion allocation. 212 Mutex* _indexedFreeListParLocks[IndexSetSize]; 213 214 // Attempt to obtain up to "n" blocks of the size "word_sz" (which is 395 void setPreconsumptionDirtyCardClosure(MemRegionClosure* cl) { 396 _preconsumptionDirtyCardClosure = cl; 397 } 398 399 // Space enquiries 400 size_t used() const; 401 size_t free() const; 402 size_t max_alloc_in_words() const; 403 // XXX: should have a less conservative used_region() than that of 404 // Space; we could consider keeping track of highest allocated 405 // address and correcting that at each sweep, as the sweeper 406 // goes through the entire allocated part of the generation. We 407 // could also use that information to keep the sweeper from 408 // sweeping more than is necessary. The allocator and sweeper will 409 // of course need to synchronize on this, since the sweeper will 410 // try to bump down the address and the allocator will try to bump it up. 411 // For now, however, we'll just use the default used_region() 412 // which overestimates the region by returning the entire 413 // committed region (this is safe, but inefficient). 414 415 // Returns a subregion of the space containing all the objects in 416 // the space. 417 MemRegion used_region() const { 418 return MemRegion(bottom(), 419 BlockOffsetArrayUseUnallocatedBlock ? 420 unallocated_block() : end()); 421 } 422 423 virtual bool is_free_block(const HeapWord* p) const; 424 425 // Resizing support 426 void set_end(HeapWord* value); // override 427 428 // Never mangle CompactibleFreeListSpace 429 void mangle_unused_area() {} 430 void mangle_unused_area_complete() {} 431 432 // Mutual exclusion support 433 Mutex* freelistLock() const { return &_freelistLock; } 434 | 175 // Linear allocation blocks 176 LinearAllocBlock _smallLinearAllocBlock; 177 178 AFLBinaryTreeDictionary* _dictionary; // Pointer to dictionary for large size blocks 179 180 // Indexed array for small size blocks 181 AdaptiveFreeList<FreeChunk> _indexedFreeList[IndexSetSize]; 182 183 // Allocation strategy 184 bool _fitStrategy; // Use best fit strategy 185 186 // This is an address close to the largest free chunk in the heap. 187 // It is currently assumed to be at the end of the heap. Free 188 // chunks with addresses greater than nearLargestChunk are coalesced 189 // in an effort to maintain a large chunk at the end of the heap. 190 HeapWord* _nearLargestChunk; 191 192 // Used to keep track of limit of sweep for the space 193 HeapWord* _sweep_limit; 194 195 // Stable value of used(). 196 size_t _used_stable; 197 198 // Used to make the young collector update the mod union table 199 MemRegionClosure* _preconsumptionDirtyCardClosure; 200 201 // Support for compacting cms 202 HeapWord* cross_threshold(HeapWord* start, HeapWord* end); 203 HeapWord* forward(oop q, size_t size, CompactPoint* cp, HeapWord* compact_top); 204 205 // Initialization helpers. 206 void initializeIndexedFreeListArray(); 207 208 // Extra stuff to manage promotion parallelism. 209 210 // A lock protecting the dictionary during par promotion allocation. 211 mutable Mutex _parDictionaryAllocLock; 212 Mutex* parDictionaryAllocLock() const { return &_parDictionaryAllocLock; } 213 214 // Locks protecting the exact lists during par promotion allocation. 215 Mutex* _indexedFreeListParLocks[IndexSetSize]; 216 217 // Attempt to obtain up to "n" blocks of the size "word_sz" (which is 398 void setPreconsumptionDirtyCardClosure(MemRegionClosure* cl) { 399 _preconsumptionDirtyCardClosure = cl; 400 } 401 402 // Space enquiries 403 size_t used() const; 404 size_t free() const; 405 size_t max_alloc_in_words() const; 406 // XXX: should have a less conservative used_region() than that of 407 // Space; we could consider keeping track of highest allocated 408 // address and correcting that at each sweep, as the sweeper 409 // goes through the entire allocated part of the generation. We 410 // could also use that information to keep the sweeper from 411 // sweeping more than is necessary. The allocator and sweeper will 412 // of course need to synchronize on this, since the sweeper will 413 // try to bump down the address and the allocator will try to bump it up. 414 // For now, however, we'll just use the default used_region() 415 // which overestimates the region by returning the entire 416 // committed region (this is safe, but inefficient). 417 418 // Returns monotonically increasing stable used space bytes for CMS. 419 // This is required for jhat and other memory monitoring tools 420 // that might otherwise see inconsistent used space values during a garbage 421 // collection, promotion or allocation into compactibleFreeListSpace. 422 // The value returned by this function might be smaller than the 423 // actual value. 424 size_t used_stable() const; 425 // Recalculate and cache the current stable used() value. Only to be called 426 // in places where we can be sure that the result is stable. 427 void recalculate_used_stable(); 428 429 // Returns a subregion of the space containing all the objects in 430 // the space. 431 MemRegion used_region() const { 432 return MemRegion(bottom(), 433 BlockOffsetArrayUseUnallocatedBlock ? 434 unallocated_block() : end()); 435 } 436 437 virtual bool is_free_block(const HeapWord* p) const; 438 439 // Resizing support 440 void set_end(HeapWord* value); // override 441 442 // Never mangle CompactibleFreeListSpace 443 void mangle_unused_area() {} 444 void mangle_unused_area_complete() {} 445 446 // Mutual exclusion support 447 Mutex* freelistLock() const { return &_freelistLock; } 448 |