src/hotspot/share/gc/g1/g1AllocRegion.hpp

rev 56448 : imported patch 8220310.mut.0
rev 56449 : imported patch 8220310.mut.1

*** 26,46 ****
  #define SHARE_GC_G1_G1ALLOCREGION_HPP
  
  #include "gc/g1/heapRegion.hpp"
  #include "gc/g1/g1EvacStats.hpp"
  #include "gc/g1/g1HeapRegionAttr.hpp"
  
  class G1CollectedHeap;
  
  // A class that holds a region that is active in satisfying allocation
  // requests, potentially issued in parallel. When the active region is
  // full it will be retired and replaced with a new one. The
  // implementation assumes that fast-path allocations will be lock-free
  // and a lock will need to be taken when the active region needs to be
  // replaced.
  
! class G1AllocRegion {
  
  private:
    // The active allocating region we are currently allocating out
    // of. The invariant is that if this object is initialized (i.e.,
    // init() has been called and release() has not) then _alloc_region
--- 26,47 ----
  #define SHARE_GC_G1_G1ALLOCREGION_HPP
  
  #include "gc/g1/heapRegion.hpp"
  #include "gc/g1/g1EvacStats.hpp"
  #include "gc/g1/g1HeapRegionAttr.hpp"
+ #include "gc/g1/g1MemoryNodeManager.hpp"
  
  class G1CollectedHeap;
  
  // A class that holds a region that is active in satisfying allocation
  // requests, potentially issued in parallel. When the active region is
  // full it will be retired and replaced with a new one. The
  // implementation assumes that fast-path allocations will be lock-free
  // and a lock will need to be taken when the active region needs to be
  // replaced.
  
! class G1AllocRegion : public CHeapObj<mtGC> {
  
  private:
    // The active allocating region we are currently allocating out
    // of. The invariant is that if this object is initialized (i.e.,
    // init() has been called and release() has not) then _alloc_region
*** 89,98 ****
--- 90,102 ----
    // G1CollectedHeap::allocate_new_alloc_region() and tells it to try
    // to allocate a new region even if the max has been reached.
    HeapWord* new_alloc_region_and_allocate(size_t word_size, bool force);
  
  protected:
+   // The memory node index this allocation region belongs to.
+   uint _node_index;
+ 
    // Reset the alloc region to point a the dummy region.
    void reset_alloc_region();
  
    // Perform a non-MT-safe allocation out of the given region.
    inline HeapWord* allocate(HeapRegion* alloc_region,
*** 129,139 ****
  
    virtual HeapRegion* allocate_new_region(size_t word_size, bool force) = 0;
    virtual void retire_region(HeapRegion* alloc_region,
                               size_t allocated_bytes) = 0;
  
!   G1AllocRegion(const char* name, bool bot_updates);
  
  public:
    static void setup(G1CollectedHeap* g1h, HeapRegion* dummy_region);
  
    HeapRegion* get() const {
--- 133,143 ----
  
    virtual HeapRegion* allocate_new_region(size_t word_size, bool force) = 0;
    virtual void retire_region(HeapRegion* alloc_region,
                               size_t allocated_bytes) = 0;
  
!   G1AllocRegion(const char* name, bool bot_updates, uint node_index);
  
  public:
    static void setup(G1CollectedHeap* g1h, HeapRegion* dummy_region);
  
    HeapRegion* get() const {
*** 218,229 ****
  protected:
    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:
!   MutatorAllocRegion()
!     : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */),
        _wasted_bytes(0),
        _retained_alloc_region(NULL) { }
  
    // Returns the combined used memory in the current alloc region and
    // the retained alloc region.
--- 222,233 ----
  protected:
    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:
!   MutatorAllocRegion(uint node_index)
!     : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */, node_index),
        _wasted_bytes(0),
        _retained_alloc_region(NULL) { }
  
    // Returns the combined used memory in the current alloc region and
    // the retained alloc region.
*** 243,252 ****
--- 247,257 ----
    // region is retired and set to NULL.
    virtual HeapRegion* release();
  
    virtual void init();
  };
+ 
  // Common base class for allocation regions used during GC.
  class G1GCAllocRegion : public G1AllocRegion {
  protected:
    G1EvacStats* _stats;
    G1HeapRegionAttr::region_type_t _purpose;
*** 254,265 ****
    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);
  
!   G1GCAllocRegion(const char* name, bool bot_updates, G1EvacStats* stats, G1HeapRegionAttr::region_type_t purpose)
!   : G1AllocRegion(name, bot_updates), _stats(stats), _purpose(purpose) {
      assert(stats != NULL, "Must pass non-NULL PLAB statistics");
    }
  };
  
  class SurvivorGCAllocRegion : public G1GCAllocRegion {
--- 259,271 ----
    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);
  
!   G1GCAllocRegion(const char* name, bool bot_updates, G1EvacStats* stats,
!                   G1HeapRegionAttr::region_type_t purpose, uint node_index = G1MemoryNodeManager::AnyNodeIndex)
!   : G1AllocRegion(name, bot_updates, node_index), _stats(stats), _purpose(purpose) {
      assert(stats != NULL, "Must pass non-NULL PLAB statistics");
    }
  };
  
  class SurvivorGCAllocRegion : public G1GCAllocRegion {