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

*** 1,7 ****
  /*
!  * Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 27,58 ****
  
  #include "gc/g1/g1MonitoringSupport.hpp"
  #include "services/memoryPool.hpp"
  #include "services/memoryUsage.hpp"
  
! // This file contains the three classes that represent the memory
! // pools of the G1 spaces: G1EdenPool, G1SurvivorPool, and
! // G1OldGenPool. In G1, unlike our other GCs, we do not have a
! // physical space for each of those spaces. Instead, we allocate
! // regions for all three spaces out of a single pool of regions (that
! // pool basically covers the entire heap). As a result, the eden,
! // survivor, and old gen are considered logical spaces in G1, as each
! // is a set of non-contiguous regions. This is also reflected in the
! // way we map them to memory pools here. The easiest way to have done
! // this would have been to map the entire G1 heap to a single memory
! // pool. However, it's helpful to show how large the eden and survivor
! // get, as this does affect the performance and behavior of G1. Which
! // is why we introduce the three memory pools implemented here.
  //
! // See comments in g1MonitoringSupport.hpp for additional details
! // on this model.
  //
  
  class G1CollectedHeap;
  
! // This class is shared by the three G1 memory pool classes
! // (G1EdenPool, G1SurvivorPool, G1OldGenPool).
  class G1MemoryPoolSuper : public CollectedMemoryPool {
  protected:
    G1MonitoringSupport* _g1mm;
  
    // Would only be called from subclasses.
--- 27,58 ----
  
  #include "gc/g1/g1MonitoringSupport.hpp"
  #include "services/memoryPool.hpp"
  #include "services/memoryUsage.hpp"
  
! // This file contains definitions for two memory pool models for the G1 heap
! // spaces. Which to use is determined by the G1UseLegacyMonitoring switch.  If
! // true, we use a model that defines three pools, G1EdenPool, G1SurvivorPool
! // and G1OldPool. If false (the default), we use a more accurate model
! // that defines two additional pools, G1HumongousPool and G1ArchivePool.
  //
! // In G1, unlike our other GCs, we do not have a contiguous virtual address
! // space for each pool. The pools are logical spaces in G1, and each pool
! // consists of a non-contiguous region set allocated out of a single region
! // pool which covers the entire heap. This is also reflected in the way we
! // map them to memory pools here. The easiest way to have done this would
! // have been to map the entire G1 heap to a single memory pool. However, it
! // is helpful to show how large each space gets, as their sizes affect G1's
! // performance and behavior.
  //
+ // See comments in g1MonitoringSupport.hpp for additional details on this
+ // model.
  
  class G1CollectedHeap;
  
! // This class is shared by all G1 memory pool classes: G1EdenPool,
! // G1SurvivorPool, G1OldPool, G1HumongousPool, and G1ArchivePool
  class G1MemoryPoolSuper : public CollectedMemoryPool {
  protected:
    G1MonitoringSupport* _g1mm;
  
    // Would only be called from subclasses.
*** 61,96 ****
                      size_t init_size,
                      size_t max_size,
                      bool support_usage_threshold);
  };
  
! // Memory pool that represents the G1 eden.
  class G1EdenPool : public G1MemoryPoolSuper {
  public:
    G1EdenPool(G1CollectedHeap* g1h, size_t initial_size);
- 
    size_t used_in_bytes() { return _g1mm->eden_space_used(); }
- 
    MemoryUsage get_memory_usage();
  };
  
! // Memory pool that represents the G1 survivor.
  class G1SurvivorPool : public G1MemoryPoolSuper {
  public:
    G1SurvivorPool(G1CollectedHeap* g1h, size_t initial_size);
- 
    size_t used_in_bytes() { return _g1mm->survivor_space_used(); }
- 
    MemoryUsage get_memory_usage();
  };
  
! // Memory pool that represents the G1 old gen.
! class G1OldGenPool : public G1MemoryPoolSuper {
  public:
!   G1OldGenPool(G1CollectedHeap* g1h, size_t initial_size, size_t max_size);
  
!   size_t used_in_bytes() { return _g1mm->old_gen_used(); }
  
    MemoryUsage get_memory_usage();
  };
  
  #endif // SHARE_VM_GC_G1_G1MEMORYPOOL_HPP
--- 61,117 ----
                      size_t init_size,
                      size_t max_size,
                      bool support_usage_threshold);
  };
  
! // In legacy mode, G1EdenPool, G1SurvivorPool, and G1OldPool represent
! // the G1 memory pools, and G1OldPool includes regions occupied by
! // humongous and archive objects.
! 
! // Memory pool that represents the G1 eden space
  class G1EdenPool : public G1MemoryPoolSuper {
  public:
    G1EdenPool(G1CollectedHeap* g1h, size_t initial_size);
    size_t used_in_bytes() { return _g1mm->eden_space_used(); }
    MemoryUsage get_memory_usage();
  };
  
! // Memory pool that represents the G1 survivor space
  class G1SurvivorPool : public G1MemoryPoolSuper {
  public:
    G1SurvivorPool(G1CollectedHeap* g1h, size_t initial_size);
    size_t used_in_bytes() { return _g1mm->survivor_space_used(); }
    MemoryUsage get_memory_usage();
  };
  
! // Memory pool that represents the G1 old generation (legacy)
! // or G1 old space (default)
! class G1OldPool : public G1MemoryPoolSuper {
  public:
!   G1OldPool(G1CollectedHeap* g1h, size_t initial_size, size_t max_size);
!   size_t used_in_bytes() { return _g1mm->old_space_used(); }
!   MemoryUsage get_memory_usage();
! };
  
! // The default model includes the three legacy pools plus G1ArchivePool
! // and G1HumongousPool, and G1OldPool does not include regions occupied
! // by humongous and archive objects. Instead, humongous and archive
! // objects each get their own pool.
! 
! // Memory pool that represents the G1 archive space. The archive space
! // contains read-only class metadata from the class data sharing archives.
! class G1ArchivePool : public G1MemoryPoolSuper {
! public:
!   G1ArchivePool(G1CollectedHeap* g1h, size_t initial_size);
!   size_t used_in_bytes() { return _g1mm->archive_space_used(); }
!   MemoryUsage get_memory_usage();
! };
  
+ // Memory pool that represents the G1 humongous space
+ class G1HumongousPool : public G1MemoryPoolSuper {
+ public:
+   G1HumongousPool(G1CollectedHeap* g1h, size_t initial_size);
+   size_t used_in_bytes() { return _g1mm->humongous_space_used(); }
    MemoryUsage get_memory_usage();
  };
  
  #endif // SHARE_VM_GC_G1_G1MEMORYPOOL_HPP