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

rev 8024 : imported patch event1
* * *
imported patch event2

*** 497,521 ****
    // First-level mutator allocation attempt: try to allocate out of
    // the mutator alloc region without taking the Heap_lock. This
    // should only be used for non-humongous allocations.
    inline HeapWord* attempt_allocation(size_t word_size,
                                        uint* gc_count_before_ret,
!                                       uint* gclocker_retry_count_ret);
  
    // Second-level mutator allocation attempt: take the Heap_lock and
    // retry the allocation attempt, potentially scheduling a GC
    // pause. This should only be used for non-humongous allocations.
    HeapWord* attempt_allocation_slow(size_t word_size,
                                      AllocationContext_t context,
                                      uint* gc_count_before_ret,
!                                     uint* gclocker_retry_count_ret);
  
    // Takes the Heap_lock and attempts a humongous allocation. It can
    // potentially schedule a GC pause.
    HeapWord* attempt_allocation_humongous(size_t word_size,
                                           uint* gc_count_before_ret,
!                                          uint* gclocker_retry_count_ret);
  
    // Allocation attempt that should be called during safepoints (e.g.,
    // at the end of a successful GC). expect_null_mutator_alloc_region
    // specifies whether the mutator alloc region is expected to be NULL
    // or not.
--- 497,524 ----
    // First-level mutator allocation attempt: try to allocate out of
    // the mutator alloc region without taking the Heap_lock. This
    // should only be used for non-humongous allocations.
    inline HeapWord* attempt_allocation(size_t word_size,
                                        uint* gc_count_before_ret,
!                                       uint* gclocker_retry_count_ret,
!                                       uint* gc_attempt);
  
    // Second-level mutator allocation attempt: take the Heap_lock and
    // retry the allocation attempt, potentially scheduling a GC
    // pause. This should only be used for non-humongous allocations.
    HeapWord* attempt_allocation_slow(size_t word_size,
                                      AllocationContext_t context,
                                      uint* gc_count_before_ret,
!                                     uint* gclocker_retry_count_ret,
!                                     uint* gc_attempt);
  
    // Takes the Heap_lock and attempts a humongous allocation. It can
    // potentially schedule a GC pause.
    HeapWord* attempt_allocation_humongous(size_t word_size,
                                           uint* gc_count_before_ret,
!                                          uint* gclocker_retry_count_ret,
!                                          uint* gc_attempt);
  
    // Allocation attempt that should be called during safepoints (e.g.,
    // at the end of a successful GC). expect_null_mutator_alloc_region
    // specifies whether the mutator alloc region is expected to be NULL
    // or not.
*** 744,754 ****
    // methods that call do_collection_pause() release the Heap_lock
    // before the call, so it's easy to read gc_count_before just before.
    HeapWord* do_collection_pause(size_t         word_size,
                                  uint           gc_count_before,
                                  bool*          succeeded,
!                                 GCCause::Cause gc_cause);
  
    // The guts of the incremental collection pause, executed by the vm
    // thread. It returns false if it is unable to do the collection due
    // to the GC locker being active, true otherwise
    bool do_collection_pause_at_safepoint(double target_pause_time_ms);
--- 747,758 ----
    // methods that call do_collection_pause() release the Heap_lock
    // before the call, so it's easy to read gc_count_before just before.
    HeapWord* do_collection_pause(size_t         word_size,
                                  uint           gc_count_before,
                                  bool*          succeeded,
!                                 GCCause::Cause gc_cause,
!                                 uint           gc_attempt);
  
    // The guts of the incremental collection pause, executed by the vm
    // thread. It returns false if it is unable to do the collection due
    // to the GC locker being active, true otherwise
    bool do_collection_pause_at_safepoint(double target_pause_time_ms);