--- old/src/share/vm/gc_implementation/g1/g1Allocator.hpp	2015-03-04 13:52:16.809955142 +0100
+++ new/src/share/vm/gc_implementation/g1/g1Allocator.hpp	2015-03-04 13:52:16.745953238 +0100
@@ -30,21 +30,21 @@
 #include "gc_implementation/g1/g1InCSetState.hpp"
 #include "gc_implementation/shared/parGCAllocBuffer.hpp"
 
-// Base class for G1 allocators.
-class G1Allocator : public CHeapObj<mtGC> {
+// Interface to keep track of which regions G1 is currently allocating into.
+class AllocRegionManager : public CHeapObj<mtGC> {
   friend class VMStructs;
-protected:
+ protected:
   G1CollectedHeap* _g1h;
 
   // Outside of GC pauses, the number of bytes used in all regions other
   // than the current allocation region.
   size_t _summary_bytes_used;
 
-public:
-   G1Allocator(G1CollectedHeap* heap) :
+ public:
+   AllocRegionManager(G1CollectedHeap* heap) :
      _g1h(heap), _summary_bytes_used(0) { }
 
-   static G1Allocator* create_allocator(G1CollectedHeap* g1h);
+   static AllocRegionManager* create_allocator(G1CollectedHeap* g1h);
 
    virtual void init_mutator_alloc_region() = 0;
    virtual void release_mutator_alloc_region() = 0;
@@ -89,9 +89,11 @@
    }
 };
 
-// The default allocator for G1.
-class G1DefaultAllocator : public G1Allocator {
-protected:
+// The default allocation region manager for G1. Provides a single mutator, survivor
+// and old generation allocation region.
+// Can retain the old generation allocation region across GCs.
+class DefaultAllocRegionManager : public AllocRegionManager {
+ protected:
   // Alloc region used to satisfy mutator allocation requests.
   MutatorAllocRegion _mutator_alloc_region;
 
@@ -104,8 +106,8 @@
   OldGCAllocRegion _old_gc_alloc_region;
 
   HeapRegion* _retained_old_gc_alloc_region;
-public:
-  G1DefaultAllocator(G1CollectedHeap* heap) : G1Allocator(heap), _retained_old_gc_alloc_region(NULL) { }
+ public:
+  DefaultAllocRegionManager(G1CollectedHeap* heap) : AllocRegionManager(heap), _retained_old_gc_alloc_region(NULL) { }
 
   virtual void init_mutator_alloc_region();
   virtual void release_mutator_alloc_region();
@@ -144,13 +146,14 @@
   }
 };
 
-class G1ParGCAllocBuffer: public ParGCAllocBuffer {
-private:
+// A PLAB used during garbage collection that is specific to G1.
+class G1PLAB: public ParGCAllocBuffer {
+ private:
   bool _retired;
 
-public:
-  G1ParGCAllocBuffer(size_t gclab_word_size);
-  virtual ~G1ParGCAllocBuffer() {
+ public:
+  G1PLAB(size_t gclab_word_size);
+  virtual ~G1PLAB() {
     guarantee(_retired, "Allocation buffer has not been retired");
   }
 
@@ -168,9 +171,12 @@
   }
 };
 
-class G1ParGCAllocator : public CHeapObj<mtGC> {
+// Manages the PLABs used during garbage collection. Interface for allocation from PLABs.
+// Needs to handle multiple contexts, extra alignment in any "survivor" area and some
+// statistics.
+class PLABAllocator : public CHeapObj<mtGC> {
   friend class G1ParScanThreadState;
-protected:
+ protected:
   G1CollectedHeap* _g1h;
 
   // The survivor alignment in effect in bytes.
@@ -187,7 +193,7 @@
   void add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
 
   virtual void retire_alloc_buffers() = 0;
-  virtual G1ParGCAllocBuffer* alloc_buffer(InCSetState dest, AllocationContext_t context) = 0;
+  virtual G1PLAB* alloc_buffer(InCSetState dest, AllocationContext_t context) = 0;
 
   // Calculate the survivor space object alignment in bytes. Returns that or 0 if
   // there are no restrictions on survivor alignment.
@@ -203,13 +209,13 @@
     }
   }
 
-public:
-  G1ParGCAllocator(G1CollectedHeap* g1h) :
+ public:
+  PLABAllocator(G1CollectedHeap* g1h) :
     _g1h(g1h), _survivor_alignment_bytes(calc_survivor_alignment_bytes()),
     _alloc_buffer_waste(0), _undo_waste(0) {
   }
 
-  static G1ParGCAllocator* create_allocator(G1CollectedHeap* g1h);
+  static PLABAllocator* create_allocator(G1CollectedHeap* g1h);
 
   size_t alloc_buffer_waste() { return _alloc_buffer_waste; }
   size_t undo_waste() {return _undo_waste; }
@@ -226,7 +232,7 @@
   HeapWord* plab_allocate(InCSetState dest,
                           size_t word_sz,
                           AllocationContext_t context) {
-    G1ParGCAllocBuffer* buffer = alloc_buffer(dest, context);
+    G1PLAB* buffer = alloc_buffer(dest, context);
     if (_survivor_alignment_bytes == 0) {
       return buffer->allocate(word_sz);
     } else {
@@ -255,15 +261,17 @@
   }
 };
 
-class G1DefaultParGCAllocator : public G1ParGCAllocator {
-  G1ParGCAllocBuffer  _surviving_alloc_buffer;
-  G1ParGCAllocBuffer  _tenured_alloc_buffer;
-  G1ParGCAllocBuffer* _alloc_buffers[InCSetState::Num];
+// The default PLAB allocator for G1. Keeps the current (single) PLAB for survivor
+// and old generation allocation.
+class DefaultPLABAllocator : public PLABAllocator {
+  G1PLAB  _surviving_alloc_buffer;
+  G1PLAB  _tenured_alloc_buffer;
+  G1PLAB* _alloc_buffers[InCSetState::Num];
 
-public:
-  G1DefaultParGCAllocator(G1CollectedHeap* g1h);
+ public:
+  DefaultPLABAllocator(G1CollectedHeap* g1h);
 
-  virtual G1ParGCAllocBuffer* alloc_buffer(InCSetState dest, AllocationContext_t context) {
+  virtual G1PLAB* alloc_buffer(InCSetState dest, AllocationContext_t context) {
     assert(dest.is_valid(),
            err_msg("Allocation buffer index out-of-bounds: " CSETSTATE_FORMAT, dest.value()));
     assert(_alloc_buffers[dest.value()] != NULL,