1 /*

     2  * Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_GC_G1_G1MEMORYPOOL_HPP

    26 #define SHARE_VM_GC_G1_G1MEMORYPOOL_HPP

    27 

    28 #include "gc/g1/g1MonitoringSupport.hpp"

    29 #include "services/memoryPool.hpp"

    30 #include "services/memoryUsage.hpp"

    31 

    32 // This file contains the three classes that represent the memory

    33 // pools of the G1 spaces: G1EdenPool, G1SurvivorPool, and

    34 // G1OldGenPool. In G1, unlike our other GCs, we do not have a

    35 // physical space for each of those spaces. Instead, we allocate

    36 // regions for all three spaces out of a single pool of regions (that

    37 // pool basically covers the entire heap). As a result, the eden,

    38 // survivor, and old gen are considered logical spaces in G1, as each

    39 // is a set of non-contiguous regions. This is also reflected in the

    40 // way we map them to memory pools here. The easiest way to have done

    41 // this would have been to map the entire G1 heap to a single memory

    42 // pool. However, it's helpful to show how large the eden and survivor

    43 // get, as this does affect the performance and behavior of G1. Which

    44 // is why we introduce the three memory pools implemented here.

    45 //

    46 // See comments in g1MonitoringSupport.hpp for additional details

    47 // on this model.

    48 //

    49 

    50 class G1CollectedHeap;

    51 

    52 // This class is shared by the three G1 memory pool classes

    53 // (G1EdenPool, G1SurvivorPool, G1OldGenPool).

    54 class G1MemoryPoolSuper : public CollectedMemoryPool {

    55 protected:

    56   const static size_t _undefined_max = (size_t) -1;

    57   G1MonitoringSupport* _g1mm;

    58 

    59   // Would only be called from subclasses.

    60   G1MemoryPoolSuper(G1CollectedHeap* g1h,

    61                     const char* name,

    62                     size_t init_size,

    63                     size_t max_size,

    64                     bool support_usage_threshold);

    65 };

    66 

    67 // Memory pool that represents the G1 eden.

    68 class G1EdenPool : public G1MemoryPoolSuper {

    69 public:

    70   G1EdenPool(G1CollectedHeap* g1h);

    71 

    72   size_t used_in_bytes() {

    73     return _g1mm->eden_space_used();

    74   }

    75   size_t max_size() const {

    76     return _undefined_max;

    77   }

    78   MemoryUsage get_memory_usage();

    79 };

    80 

    81 // Memory pool that represents the G1 survivor.

    82 class G1SurvivorPool : public G1MemoryPoolSuper {

    83 public:

    84   G1SurvivorPool(G1CollectedHeap* g1h);

    85 

    86   size_t used_in_bytes() {

    87     return _g1mm->survivor_space_used();

    88   }

    89   size_t max_size() const {

    90     return _undefined_max;

    91   }

    92   MemoryUsage get_memory_usage();

    93 };

    94 

    95 // Memory pool that represents the G1 old gen.

    96 class G1OldGenPool : public G1MemoryPoolSuper {

    97 public:

    98   G1OldGenPool(G1CollectedHeap* g1h);

    99 

   100   size_t used_in_bytes() {

   101     return _g1mm->old_space_used();

   102   }

   103   size_t max_size() const {

   104     return _g1mm->old_gen_max();

   105   }

   106   MemoryUsage get_memory_usage();

   107 };

   108 

   109 #endif // SHARE_VM_GC_G1_G1MEMORYPOOL_HPP