g1MemoryPool.cpp revision 1879:f95d63e2154a 
1/*
2 * Copyright (c) 2007, 2010, 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#include "precompiled.hpp"
26#include "gc_implementation/g1/g1CollectedHeap.hpp"
27#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
28#include "gc_implementation/g1/g1CollectorPolicy.hpp"
29#include "gc_implementation/g1/heapRegion.hpp"
30#include "services/g1MemoryPool.hpp"
31
32G1MemoryPoolSuper::G1MemoryPoolSuper(G1CollectedHeap* g1h,
33                                     const char* name,
34                                     size_t init_size,
35                                     bool support_usage_threshold) :
36  _g1h(g1h), CollectedMemoryPool(name,
37                                 MemoryPool::Heap,
38                                 init_size,
39                                 undefined_max(),
40                                 support_usage_threshold) {
41  assert(UseG1GC, "sanity");
42}
43
44// See the comment at the top of g1MemoryPool.hpp
45size_t G1MemoryPoolSuper::eden_space_committed(G1CollectedHeap* g1h) {
46  return MAX2(eden_space_used(g1h), (size_t) HeapRegion::GrainBytes);
47}
48
49// See the comment at the top of g1MemoryPool.hpp
50size_t G1MemoryPoolSuper::eden_space_used(G1CollectedHeap* g1h) {
51  size_t young_list_length = g1h->young_list()->length();
52  size_t eden_used = young_list_length * HeapRegion::GrainBytes;
53  size_t survivor_used = survivor_space_used(g1h);
54  eden_used = subtract_up_to_zero(eden_used, survivor_used);
55  return eden_used;
56}
57
58// See the comment at the top of g1MemoryPool.hpp
59size_t G1MemoryPoolSuper::survivor_space_committed(G1CollectedHeap* g1h) {
60  return MAX2(survivor_space_used(g1h), (size_t) HeapRegion::GrainBytes);
61}
62
63// See the comment at the top of g1MemoryPool.hpp
64size_t G1MemoryPoolSuper::survivor_space_used(G1CollectedHeap* g1h) {
65  size_t survivor_num = g1h->g1_policy()->recorded_survivor_regions();
66  size_t survivor_used = survivor_num * HeapRegion::GrainBytes;
67  return survivor_used;
68}
69
70// See the comment at the top of g1MemoryPool.hpp
71size_t G1MemoryPoolSuper::old_space_committed(G1CollectedHeap* g1h) {
72  size_t committed = overall_committed(g1h);
73  size_t eden_committed = eden_space_committed(g1h);
74  size_t survivor_committed = survivor_space_committed(g1h);
75  committed = subtract_up_to_zero(committed, eden_committed);
76  committed = subtract_up_to_zero(committed, survivor_committed);
77  committed = MAX2(committed, (size_t) HeapRegion::GrainBytes);
78  return committed;
79}
80
81// See the comment at the top of g1MemoryPool.hpp
82size_t G1MemoryPoolSuper::old_space_used(G1CollectedHeap* g1h) {
83  size_t used = overall_used(g1h);
84  size_t eden_used = eden_space_used(g1h);
85  size_t survivor_used = survivor_space_used(g1h);
86  used = subtract_up_to_zero(used, eden_used);
87  used = subtract_up_to_zero(used, survivor_used);
88  return used;
89}
90
91G1EdenPool::G1EdenPool(G1CollectedHeap* g1h) :
92  G1MemoryPoolSuper(g1h,
93                    "G1 Eden",
94                    eden_space_committed(g1h), /* init_size */
95                    false /* support_usage_threshold */) { }
96
97MemoryUsage G1EdenPool::get_memory_usage() {
98  size_t initial_sz = initial_size();
99  size_t max_sz     = max_size();
100  size_t used       = used_in_bytes();
101  size_t committed  = eden_space_committed(_g1h);
102
103  return MemoryUsage(initial_sz, used, committed, max_sz);
104}
105
106G1SurvivorPool::G1SurvivorPool(G1CollectedHeap* g1h) :
107  G1MemoryPoolSuper(g1h,
108                    "G1 Survivor",
109                    survivor_space_committed(g1h), /* init_size */
110                    false /* support_usage_threshold */) { }
111
112MemoryUsage G1SurvivorPool::get_memory_usage() {
113  size_t initial_sz = initial_size();
114  size_t max_sz     = max_size();
115  size_t used       = used_in_bytes();
116  size_t committed  = survivor_space_committed(_g1h);
117
118  return MemoryUsage(initial_sz, used, committed, max_sz);
119}
120
121G1OldGenPool::G1OldGenPool(G1CollectedHeap* g1h) :
122  G1MemoryPoolSuper(g1h,
123                    "G1 Old Gen",
124                    old_space_committed(g1h), /* init_size */
125                    true /* support_usage_threshold */) { }
126
127MemoryUsage G1OldGenPool::get_memory_usage() {
128  size_t initial_sz = initial_size();
129  size_t max_sz     = max_size();
130  size_t used       = used_in_bytes();
131  size_t committed  = old_space_committed(_g1h);
132
133  return MemoryUsage(initial_sz, used, committed, max_sz);
134}
135