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

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

@@ -497,25 +497,28 @@
   // 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* 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* 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* 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,11 +747,12 @@
   // 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);
+                                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);