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

rev 7474 : imported patch cleanup

*** 338,352 ****
    // (c) cause == _g1_humongous_allocation
    bool should_do_concurrent_full_gc(GCCause::Cause cause);
  
    // Keeps track of how many "old marking cycles" (i.e., Full GCs or
    // concurrent cycles) we have started.
!   volatile unsigned int _old_marking_cycles_started;
  
    // Keeps track of how many "old marking cycles" (i.e., Full GCs or
    // concurrent cycles) we have completed.
!   volatile unsigned int _old_marking_cycles_completed;
  
    bool _concurrent_cycle_started;
    bool _heap_summary_sent;
  
    // This is a non-product method that is helpful for testing. It is
--- 338,352 ----
    // (c) cause == _g1_humongous_allocation
    bool should_do_concurrent_full_gc(GCCause::Cause cause);
  
    // Keeps track of how many "old marking cycles" (i.e., Full GCs or
    // concurrent cycles) we have started.
!   volatile uint _old_marking_cycles_started;
  
    // Keeps track of how many "old marking cycles" (i.e., Full GCs or
    // concurrent cycles) we have completed.
!   volatile uint _old_marking_cycles_completed;
  
    bool _concurrent_cycle_started;
    bool _heap_summary_sent;
  
    // This is a non-product method that is helpful for testing. It is
*** 510,535 ****
  
    // 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,
!                                       unsigned int* gc_count_before_ret,
!                                       int* 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,
!                                     unsigned int* gc_count_before_ret,
!                                     int* 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,
!                                          unsigned int* gc_count_before_ret,
!                                          int* 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.
--- 510,535 ----
  
    // 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.
*** 714,724 ****
    // the FullGCCount_lock in case a Java thread is waiting for a full
    // GC to happen (e.g., it called System.gc() with
    // +ExplicitGCInvokesConcurrent).
    void increment_old_marking_cycles_completed(bool concurrent);
  
!   unsigned int old_marking_cycles_completed() {
      return _old_marking_cycles_completed;
    }
  
    void register_concurrent_cycle_start(const Ticks& start_time);
    void register_concurrent_cycle_end();
--- 714,724 ----
    // the FullGCCount_lock in case a Java thread is waiting for a full
    // GC to happen (e.g., it called System.gc() with
    // +ExplicitGCInvokesConcurrent).
    void increment_old_marking_cycles_completed(bool concurrent);
  
!   uint old_marking_cycles_completed() {
      return _old_marking_cycles_completed;
    }
  
    void register_concurrent_cycle_start(const Ticks& start_time);
    void register_concurrent_cycle_end();
*** 773,783 ****
    // gc_count_before (i.e., total_collections()) as a parameter since
    // it has to be read while holding the Heap_lock. Currently, both
    // 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,
!                                 unsigned int   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
--- 773,783 ----
    // gc_count_before (i.e., total_collections()) as a parameter since
    // it has to be read while holding the Heap_lock. Currently, both
    // 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
*** 1009,1019 ****
    // Time stamp to validate the regions recorded in the cache
    // used by G1CollectedHeap::start_cset_region_for_worker().
    // The heap region entry for a given worker is valid iff
    // the associated time stamp value matches the current value
    // of G1CollectedHeap::_gc_time_stamp.
!   unsigned int* _worker_cset_start_region_time_stamp;
  
    enum G1H_process_roots_tasks {
      G1H_PS_filter_satb_buffers,
      G1H_PS_refProcessor_oops_do,
      // Leave this one last.
--- 1009,1019 ----
    // Time stamp to validate the regions recorded in the cache
    // used by G1CollectedHeap::start_cset_region_for_worker().
    // The heap region entry for a given worker is valid iff
    // the associated time stamp value matches the current value
    // of G1CollectedHeap::_gc_time_stamp.
!   uint* _worker_cset_start_region_time_stamp;
  
    enum G1H_process_roots_tasks {
      G1H_PS_filter_satb_buffers,
      G1H_PS_refProcessor_oops_do,
      // Leave this one last.