src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp

Print this page




 594                                          unsigned int* gc_count_before_ret,
 595                                          int* gclocker_retry_count_ret);
 596 
 597   // Allocation attempt that should be called during safepoints (e.g.,
 598   // at the end of a successful GC). expect_null_mutator_alloc_region
 599   // specifies whether the mutator alloc region is expected to be NULL
 600   // or not.
 601   HeapWord* attempt_allocation_at_safepoint(size_t word_size,
 602                                        bool expect_null_mutator_alloc_region);
 603 
 604   // It dirties the cards that cover the block so that so that the post
 605   // write barrier never queues anything when updating objects on this
 606   // block. It is assumed (and in fact we assert) that the block
 607   // belongs to a young region.
 608   inline void dirty_young_block(HeapWord* start, size_t word_size);
 609 
 610   // Allocate blocks during garbage collection. Will ensure an
 611   // allocation region, either by picking one or expanding the
 612   // heap, and then allocate a block of the given size. The block
 613   // may not be a humongous - it must fit into a single heap region.
 614   HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size);

 615 
 616   HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose,
 617                                     HeapRegion*    alloc_region,
 618                                     bool           par,
 619                                     size_t         word_size);
 620 
 621   // Ensure that no further allocations can happen in "r", bearing in mind
 622   // that parallel threads might be attempting allocations.
 623   void par_allocate_remaining_space(HeapRegion* r);
 624 
 625   // Allocation attempt during GC for a survivor object / PLAB.
 626   inline HeapWord* survivor_attempt_allocation(size_t word_size);
 627 
 628   // Allocation attempt during GC for an old object / PLAB.
 629   inline HeapWord* old_attempt_allocation(size_t word_size);
 630 
 631   // These methods are the "callbacks" from the G1AllocRegion class.
 632 
 633   // For mutator alloc regions.
 634   HeapRegion* new_mutator_alloc_region(size_t word_size, bool force);




 594                                          unsigned int* gc_count_before_ret,
 595                                          int* gclocker_retry_count_ret);
 596 
 597   // Allocation attempt that should be called during safepoints (e.g.,
 598   // at the end of a successful GC). expect_null_mutator_alloc_region
 599   // specifies whether the mutator alloc region is expected to be NULL
 600   // or not.
 601   HeapWord* attempt_allocation_at_safepoint(size_t word_size,
 602                                        bool expect_null_mutator_alloc_region);
 603 
 604   // It dirties the cards that cover the block so that so that the post
 605   // write barrier never queues anything when updating objects on this
 606   // block. It is assumed (and in fact we assert) that the block
 607   // belongs to a young region.
 608   inline void dirty_young_block(HeapWord* start, size_t word_size);
 609 
 610   // Allocate blocks during garbage collection. Will ensure an
 611   // allocation region, either by picking one or expanding the
 612   // heap, and then allocate a block of the given size. The block
 613   // may not be a humongous - it must fit into a single heap region.
 614   HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size,
 615                                    oop const old, uint age);
 616 
 617   HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose,
 618                                     HeapRegion*    alloc_region,
 619                                     bool           par,
 620                                     size_t         word_size);
 621 
 622   // Ensure that no further allocations can happen in "r", bearing in mind
 623   // that parallel threads might be attempting allocations.
 624   void par_allocate_remaining_space(HeapRegion* r);
 625 
 626   // Allocation attempt during GC for a survivor object / PLAB.
 627   inline HeapWord* survivor_attempt_allocation(size_t word_size);
 628 
 629   // Allocation attempt during GC for an old object / PLAB.
 630   inline HeapWord* old_attempt_allocation(size_t word_size);
 631 
 632   // These methods are the "callbacks" from the G1AllocRegion class.
 633 
 634   // For mutator alloc regions.
 635   HeapRegion* new_mutator_alloc_region(size_t word_size, bool force);