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

rev 7903 : imported patch 8073013-add-detailed-information-about-plab-memory-usage
rev 7905 : imported patch 8067336-allow-that-plab-allocations-at-the-end-of-regions-are-flexible

@@ -24,10 +24,12 @@
 
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCREGION_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCREGION_HPP
 
 #include "gc_implementation/g1/heapRegion.hpp"
+#include "gc_implementation/g1/g1EvacStats.hpp"
+#include "gc_implementation/g1/g1InCSetState.hpp"
 
 class G1CollectedHeap;
 
 // 0 -> no tracing, 1 -> basic tracing, 2 -> basic + allocation tracing
 #define G1_ALLOC_REGION_TRACING 0

@@ -99,22 +101,23 @@
                                    bool bot_updates);
 
   // Perform a MT-safe allocation out of the given region.
   static inline HeapWord* par_allocate(HeapRegion* alloc_region,
                                        size_t word_size,
+                                       bool bot_updates) { return par_allocate(alloc_region, word_size, word_size, bot_updates); }
+  static inline HeapWord* par_allocate(HeapRegion* alloc_region,
+                                       size_t min_word_size,
+                                       size_t& word_size,
                                        bool bot_updates);
 
   // Ensure that the region passed as a parameter has been filled up
   // so that noone else can allocate out of it any more.
-  static void fill_up_remaining_space(HeapRegion* alloc_region,
+  // Returns the number of bytes that have been wasted by filled up
+  // the space.
+  static size_t fill_up_remaining_space(HeapRegion* alloc_region,
                                       bool bot_updates);
 
-  // Retire the active allocating region. If fill_up is true then make
-  // sure that the region is full before we retire it so that noone
-  // else can allocate out of it.
-  void retire(bool fill_up);
-
   // After a region is allocated by alloc_new_region, this
   // method is used to set it as the active alloc_region
   void update_alloc_region(HeapRegion* alloc_region);
 
   // Allocate a new active region and use it to perform a word_size

@@ -124,10 +127,16 @@
   HeapWord* new_alloc_region_and_allocate(size_t word_size, bool force);
 
   void fill_in_ext_msg(ar_ext_msg* msg, const char* message);
 
 protected:
+  // Retire the active allocating region. If fill_up is true then make
+  // sure that the region is full before we retire it so that no one
+  // else can allocate out of it.
+  // Returns the number of bytes that have been filled up during retire.
+  virtual size_t retire(bool fill_up);
+
   // For convenience as subclasses use it.
   static G1CollectedHeap* _g1h;
 
   virtual HeapRegion* allocate_new_region(size_t word_size, bool force) = 0;
   virtual void retire_region(HeapRegion* alloc_region,

@@ -152,19 +161,26 @@
   // The following two are the building blocks for the allocation method.
 
   // First-level allocation: Should be called without holding a
   // lock. It will try to allocate lock-free out of the active region,
   // or return NULL if it was unable to.
-  inline HeapWord* attempt_allocation(size_t word_size, bool bot_updates);
+  inline HeapWord* attempt_allocation(size_t word_size,
+                                      bool bot_updates) { return attempt_allocation(word_size, word_size, bot_updates); }
+  inline HeapWord* attempt_allocation(size_t min_word_size,
+                                      size_t& word_size,
+                                      bool bot_updates);
 
   // Second-level allocation: Should be called while holding a
   // lock. It will try to first allocate lock-free out of the active
   // region or, if it's unable to, it will try to replace the active
   // alloc region with a new one. We require that the caller takes the
   // appropriate lock before calling this so that it is easier to make
   // it conform to its locking protocol.
   inline HeapWord* attempt_allocation_locked(size_t word_size,
+                                             bool bot_updates) { return attempt_allocation_locked(word_size, word_size, bot_updates); }
+  inline HeapWord* attempt_allocation_locked(size_t min_word_size,
+                                             size_t& word_size,
                                              bool bot_updates);
 
   // Should be called to allocate a new region even if the max of this
   // type of regions has been reached. Should only be called if other
   // allocation attempts have failed and we are not holding a valid

@@ -199,26 +215,37 @@
 public:
   MutatorAllocRegion()
     : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
 };
 
-class SurvivorGCAllocRegion : public G1AllocRegion {
+// Common base class for allocation regions used during GC.
+class G1GCAllocRegion : public G1AllocRegion {
 protected:
+  G1EvacStats* _stats;
+  InCSetState::in_cset_state_t _purpose;
+
   virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
   virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
+
+  virtual size_t retire(bool fill_up);
 public:
-  SurvivorGCAllocRegion()
-  : G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { }
+  G1GCAllocRegion(const char* name, bool bot_updates, G1EvacStats* stats, InCSetState::in_cset_state_t purpose)
+  : G1AllocRegion(name, bot_updates), _stats(stats), _purpose(purpose) {
+    assert(stats != NULL, "Must pass non-NULL PLAB statistics");
+  }
 };
 
-class OldGCAllocRegion : public G1AllocRegion {
-protected:
-  virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
-  virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
+class SurvivorGCAllocRegion : public G1GCAllocRegion {
+public:
+  SurvivorGCAllocRegion(G1EvacStats* stats)
+  : G1GCAllocRegion("Survivor GC Alloc Region", false /* bot_updates */, stats, InCSetState::Young) { }
+};
+
+class OldGCAllocRegion : public G1GCAllocRegion {
 public:
-  OldGCAllocRegion()
-  : G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { }
+  OldGCAllocRegion(G1EvacStats* stats)
+  : G1GCAllocRegion("Old GC Alloc Region", true /* bot_updates */, stats, InCSetState::Old) { }
 
   // This specialization of release() makes sure that the last card that has
   // been allocated into has been completely filled by a dummy object.  This
   // avoids races when remembered set scanning wants to update the BOT of the
   // last card in the retained old gc alloc region, and allocation threads