1/*
2 * Copyright (c) 2003, 2015, 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/parallel/adjoiningGenerations.hpp"
27#include "gc/parallel/adjoiningVirtualSpaces.hpp"
28#include "gc/parallel/generationSizer.hpp"
29#include "gc/parallel/parallelScavengeHeap.hpp"
30#include "logging/log.hpp"
31#include "logging/logStream.hpp"
32#include "memory/resourceArea.hpp"
33#include "utilities/align.hpp"
34#include "utilities/ostream.hpp"
35
36// If boundary moving is being used, create the young gen and old
37// gen with ASPSYoungGen and ASPSOldGen, respectively.  Revert to
38// the old behavior otherwise (with PSYoungGen and PSOldGen).
39
40AdjoiningGenerations::AdjoiningGenerations(ReservedSpace old_young_rs,
41                                           GenerationSizer* policy,
42                                           size_t alignment) :
43  _virtual_spaces(old_young_rs, policy->min_old_size(),
44                  policy->min_young_size(), alignment) {
45  size_t init_low_byte_size = policy->initial_old_size();
46  size_t min_low_byte_size = policy->min_old_size();
47  size_t max_low_byte_size = policy->max_old_size();
48  size_t init_high_byte_size = policy->initial_young_size();
49  size_t min_high_byte_size = policy->min_young_size();
50  size_t max_high_byte_size = policy->max_young_size();
51
52  assert(min_low_byte_size <= init_low_byte_size &&
53         init_low_byte_size <= max_low_byte_size, "Parameter check");
54  assert(min_high_byte_size <= init_high_byte_size &&
55         init_high_byte_size <= max_high_byte_size, "Parameter check");
56  // Create the generations differently based on the option to
57  // move the boundary.
58  if (UseAdaptiveGCBoundary) {
59    // Initialize the adjoining virtual spaces.  Then pass the
60    // a virtual to each generation for initialization of the
61    // generation.
62
63    // Does the actual creation of the virtual spaces
64    _virtual_spaces.initialize(max_low_byte_size,
65                               init_low_byte_size,
66                               init_high_byte_size);
67
68    // Place the young gen at the high end.  Passes in the virtual space.
69    _young_gen = new ASPSYoungGen(_virtual_spaces.high(),
70                                  _virtual_spaces.high()->committed_size(),
71                                  min_high_byte_size,
72                                  _virtual_spaces.high_byte_size_limit());
73
74    // Place the old gen at the low end. Passes in the virtual space.
75    _old_gen = new ASPSOldGen(_virtual_spaces.low(),
76                              _virtual_spaces.low()->committed_size(),
77                              min_low_byte_size,
78                              _virtual_spaces.low_byte_size_limit(),
79                              "old", 1);
80
81    young_gen()->initialize_work();
82    assert(young_gen()->reserved().byte_size() <= young_gen()->gen_size_limit(),
83     "Consistency check");
84    assert(old_young_rs.size() >= young_gen()->gen_size_limit(),
85     "Consistency check");
86
87    old_gen()->initialize_work("old", 1);
88    assert(old_gen()->reserved().byte_size() <= old_gen()->gen_size_limit(),
89     "Consistency check");
90    assert(old_young_rs.size() >= old_gen()->gen_size_limit(),
91     "Consistency check");
92  } else {
93
94    // Layout the reserved space for the generations.
95    ReservedSpace old_rs   =
96      virtual_spaces()->reserved_space().first_part(max_low_byte_size);
97    ReservedSpace heap_rs  =
98      virtual_spaces()->reserved_space().last_part(max_low_byte_size);
99    ReservedSpace young_rs = heap_rs.first_part(max_high_byte_size);
100    assert(young_rs.size() == heap_rs.size(), "Didn't reserve all of the heap");
101
102    // Create the generations.  Virtual spaces are not passed in.
103    _young_gen = new PSYoungGen(init_high_byte_size,
104                                min_high_byte_size,
105                                max_high_byte_size);
106    _old_gen = new PSOldGen(init_low_byte_size,
107                            min_low_byte_size,
108                            max_low_byte_size,
109                            "old", 1);
110
111    // The virtual spaces are created by the initialization of the gens.
112    _young_gen->initialize(young_rs, alignment);
113    assert(young_gen()->gen_size_limit() == young_rs.size(),
114      "Consistency check");
115    _old_gen->initialize(old_rs, alignment, "old", 1);
116    assert(old_gen()->gen_size_limit() == old_rs.size(), "Consistency check");
117  }
118}
119
120size_t AdjoiningGenerations::reserved_byte_size() {
121  return virtual_spaces()->reserved_space().size();
122}
123
124void log_before_expansion(bool old, size_t expand_in_bytes, size_t change_in_bytes, size_t max_size) {
125  Log(heap, ergo) log;
126  if (!log.is_debug()) {
127   return;
128  }
129  log.debug("Before expansion of %s gen with boundary move", old ? "old" : "young");
130  log.debug("  Requested change: " SIZE_FORMAT_HEX "  Attempted change: " SIZE_FORMAT_HEX,
131                        expand_in_bytes, change_in_bytes);
132  ResourceMark rm;
133  LogStream ls(log.debug());
134  ParallelScavengeHeap::heap()->print_on(&ls);
135  log.debug("  PS%sGen max size: " SIZE_FORMAT "K", old ? "Old" : "Young", max_size/K);
136}
137
138void log_after_expansion(bool old, size_t max_size) {
139  Log(heap, ergo) log;
140  if (!log.is_debug()) {
141   return;
142  }
143  log.debug("After expansion of %s gen with boundary move", old ? "old" : "young");
144  ResourceMark rm;
145  LogStream ls(log.debug());
146  ParallelScavengeHeap::heap()->print_on(&ls);
147  log.debug("  PS%sGen max size: " SIZE_FORMAT "K", old ? "Old" : "Young", max_size/K);
148}
149
150// Make checks on the current sizes of the generations and
151// the constraints on the sizes of the generations.  Push
152// up the boundary within the constraints.  A partial
153// push can occur.
154void AdjoiningGenerations::request_old_gen_expansion(size_t expand_in_bytes) {
155  assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
156
157  assert_lock_strong(ExpandHeap_lock);
158  assert_locked_or_safepoint(Heap_lock);
159
160  // These sizes limit the amount the boundaries can move.  Effectively,
161  // the generation says how much it is willing to yield to the other
162  // generation.
163  const size_t young_gen_available = young_gen()->available_for_contraction();
164  const size_t old_gen_available = old_gen()->available_for_expansion();
165  const size_t alignment = virtual_spaces()->alignment();
166  size_t change_in_bytes = MIN3(young_gen_available,
167                                old_gen_available,
168                                align_up(expand_in_bytes, alignment));
169
170  if (change_in_bytes == 0) {
171    return;
172  }
173
174  log_before_expansion(true, expand_in_bytes, change_in_bytes, old_gen()->max_gen_size());
175
176  // Move the boundary between the generations up (smaller young gen).
177  if (virtual_spaces()->adjust_boundary_up(change_in_bytes)) {
178    young_gen()->reset_after_change();
179    old_gen()->reset_after_change();
180  }
181
182  // The total reserved for the generations should match the sum
183  // of the two even if the boundary is moving.
184  assert(reserved_byte_size() ==
185         old_gen()->max_gen_size() + young_gen()->max_size(),
186         "Space is missing");
187  young_gen()->space_invariants();
188  old_gen()->space_invariants();
189
190  log_after_expansion(true, old_gen()->max_gen_size());
191}
192
193// See comments on request_old_gen_expansion()
194bool AdjoiningGenerations::request_young_gen_expansion(size_t expand_in_bytes) {
195  assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
196
197  // If eden is not empty, the boundary can be moved but no advantage
198  // can be made of the move since eden cannot be moved.
199  if (!young_gen()->eden_space()->is_empty()) {
200    return false;
201  }
202
203
204  bool result = false;
205  const size_t young_gen_available = young_gen()->available_for_expansion();
206  const size_t old_gen_available = old_gen()->available_for_contraction();
207  const size_t alignment = virtual_spaces()->alignment();
208  size_t change_in_bytes = MIN3(young_gen_available,
209                                old_gen_available,
210                                align_up(expand_in_bytes, alignment));
211
212  if (change_in_bytes == 0) {
213    return false;
214  }
215
216  log_before_expansion(false, expand_in_bytes, change_in_bytes, young_gen()->max_size());
217
218  // Move the boundary between the generations down (smaller old gen).
219  MutexLocker x(ExpandHeap_lock);
220  if (virtual_spaces()->adjust_boundary_down(change_in_bytes)) {
221    young_gen()->reset_after_change();
222    old_gen()->reset_after_change();
223    result = true;
224  }
225
226  // The total reserved for the generations should match the sum
227  // of the two even if the boundary is moving.
228  assert(reserved_byte_size() ==
229         old_gen()->max_gen_size() + young_gen()->max_size(),
230         "Space is missing");
231  young_gen()->space_invariants();
232  old_gen()->space_invariants();
233
234  log_after_expansion(false, young_gen()->max_size());
235
236  return result;
237}
238
239// Additional space is needed in the old generation.  Try to move the boundary
240// up to meet the need.  Moves boundary up only
241void AdjoiningGenerations::adjust_boundary_for_old_gen_needs(
242  size_t desired_free_space) {
243  assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
244
245  // Stress testing.
246  if (PSAdaptiveSizePolicyResizeVirtualSpaceAlot == 1) {
247    MutexLocker x(ExpandHeap_lock);
248    request_old_gen_expansion(virtual_spaces()->alignment() * 3 / 2);
249  }
250
251  // Expand only if the entire generation is already committed.
252  if (old_gen()->virtual_space()->uncommitted_size() == 0) {
253    if (old_gen()->free_in_bytes() < desired_free_space) {
254      MutexLocker x(ExpandHeap_lock);
255      request_old_gen_expansion(desired_free_space);
256    }
257  }
258}
259
260// See comment on adjust_boundary_for_old_gen_needss().
261// Adjust boundary down only.
262void AdjoiningGenerations::adjust_boundary_for_young_gen_needs(size_t eden_size,
263    size_t survivor_size) {
264
265  assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
266
267  // Stress testing.
268  if (PSAdaptiveSizePolicyResizeVirtualSpaceAlot == 0) {
269    request_young_gen_expansion(virtual_spaces()->alignment() * 3 / 2);
270    eden_size = young_gen()->eden_space()->capacity_in_bytes();
271  }
272
273  // Expand only if the entire generation is already committed.
274  if (young_gen()->virtual_space()->uncommitted_size() == 0) {
275    size_t desired_size = eden_size + 2 * survivor_size;
276    const size_t committed = young_gen()->virtual_space()->committed_size();
277    if (desired_size > committed) {
278      request_young_gen_expansion(desired_size - committed);
279    }
280  }
281}
282