hotspot/src/share/vm/gc/shared/collectorPolicy.cpp
author david
Tue, 29 Sep 2015 11:02:08 +0200
changeset 33105 294e48b4f704
parent 32362 a487889ff52d
child 33212 906b3d079b13
permissions -rw-r--r--
8080775: Better argument formatting for assert() and friends Reviewed-by: kbarrett, pliden
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 27898
diff changeset
     2
 * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5343
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5343
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5343
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    25
#include "precompiled.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    26
#include "gc/shared/adaptiveSizePolicy.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    27
#include "gc/shared/cardTableRS.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    28
#include "gc/shared/collectorPolicy.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    29
#include "gc/shared/gcLocker.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    30
#include "gc/shared/gcPolicyCounters.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    31
#include "gc/shared/genCollectedHeap.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    32
#include "gc/shared/generationSpec.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    33
#include "gc/shared/space.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30173
diff changeset
    34
#include "gc/shared/vmGCOperations.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    35
#include "memory/universe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    36
#include "runtime/arguments.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    37
#include "runtime/globals_extension.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    38
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    39
#include "runtime/java.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14291
diff changeset
    40
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    41
#include "runtime/vmThread.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15091
diff changeset
    42
#include "utilities/macros.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
    44
// CollectorPolicy methods
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    46
CollectorPolicy::CollectorPolicy() :
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    47
    _space_alignment(0),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    48
    _heap_alignment(0),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    49
    _initial_heap_byte_size(InitialHeapSize),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    50
    _max_heap_byte_size(MaxHeapSize),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    51
    _min_heap_byte_size(Arguments::min_heap_size()),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    52
    _max_heap_size_cmdline(false),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    53
    _size_policy(NULL),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    54
    _should_clear_all_soft_refs(false),
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    55
    _all_soft_refs_clear(false)
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    56
{}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    57
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    58
#ifdef ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    59
void CollectorPolicy::assert_flags() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    60
  assert(InitialHeapSize <= MaxHeapSize, "Ergonomics decided on incompatible initial and maximum heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    61
  assert(InitialHeapSize % _heap_alignment == 0, "InitialHeapSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    62
  assert(MaxHeapSize % _heap_alignment == 0, "MaxHeapSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    63
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    64
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    65
void CollectorPolicy::assert_size_info() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    66
  assert(InitialHeapSize == _initial_heap_byte_size, "Discrepancy between InitialHeapSize flag and local storage");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    67
  assert(MaxHeapSize == _max_heap_byte_size, "Discrepancy between MaxHeapSize flag and local storage");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    68
  assert(_max_heap_byte_size >= _min_heap_byte_size, "Ergonomics decided on incompatible minimum and maximum heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    69
  assert(_initial_heap_byte_size >= _min_heap_byte_size, "Ergonomics decided on incompatible initial and minimum heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    70
  assert(_max_heap_byte_size >= _initial_heap_byte_size, "Ergonomics decided on incompatible initial and maximum heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    71
  assert(_min_heap_byte_size % _heap_alignment == 0, "min_heap_byte_size alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    72
  assert(_initial_heap_byte_size % _heap_alignment == 0, "initial_heap_byte_size alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    73
  assert(_max_heap_byte_size % _heap_alignment == 0, "max_heap_byte_size alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    74
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    75
#endif // ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    76
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
void CollectorPolicy::initialize_flags() {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    78
  assert(_space_alignment != 0, "Space alignment not set up properly");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    79
  assert(_heap_alignment != 0, "Heap alignment not set up properly");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    80
  assert(_heap_alignment >= _space_alignment,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
    81
         "heap_alignment: " SIZE_FORMAT " less than space_alignment: " SIZE_FORMAT,
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
    82
         _heap_alignment, _space_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    83
  assert(_heap_alignment % _space_alignment == 0,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
    84
         "heap_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
    85
         _heap_alignment, _space_alignment);
17320
e7e94e2542e4 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents: 17031
diff changeset
    86
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    87
  if (FLAG_IS_CMDLINE(MaxHeapSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    88
    if (FLAG_IS_CMDLINE(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    89
      vm_exit_during_initialization("Initial heap size set to a larger value than the maximum heap size");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    90
    }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    91
    if (_min_heap_byte_size != 0 && MaxHeapSize < _min_heap_byte_size) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    92
      vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    93
    }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    94
    _max_heap_size_cmdline = true;
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    95
  }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    96
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    97
  // Check heap parameter properties
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    98
  if (InitialHeapSize < M) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    99
    vm_exit_during_initialization("Too small initial heap");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   100
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   101
  if (_min_heap_byte_size < M) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   102
    vm_exit_during_initialization("Too small minimum heap");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   103
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   104
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   105
  // User inputs from -Xmx and -Xms must be aligned
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   106
  _min_heap_byte_size = align_size_up(_min_heap_byte_size, _heap_alignment);
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   107
  size_t aligned_initial_heap_size = align_size_up(InitialHeapSize, _heap_alignment);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   108
  size_t aligned_max_heap_size = align_size_up(MaxHeapSize, _heap_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   109
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   110
  // Write back to flags if the values changed
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   111
  if (aligned_initial_heap_size != InitialHeapSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   112
    FLAG_SET_ERGO(size_t, InitialHeapSize, aligned_initial_heap_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   113
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   114
  if (aligned_max_heap_size != MaxHeapSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   115
    FLAG_SET_ERGO(size_t, MaxHeapSize, aligned_max_heap_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   116
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   117
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   118
  if (FLAG_IS_CMDLINE(InitialHeapSize) && _min_heap_byte_size != 0 &&
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   119
      InitialHeapSize < _min_heap_byte_size) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   120
    vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   121
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   122
  if (!FLAG_IS_DEFAULT(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   123
    FLAG_SET_ERGO(size_t, MaxHeapSize, InitialHeapSize);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   124
  } else if (!FLAG_IS_DEFAULT(MaxHeapSize) && InitialHeapSize > MaxHeapSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   125
    FLAG_SET_ERGO(size_t, InitialHeapSize, MaxHeapSize);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   126
    if (InitialHeapSize < _min_heap_byte_size) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   127
      _min_heap_byte_size = InitialHeapSize;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   128
    }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   129
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   130
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   131
  _initial_heap_byte_size = InitialHeapSize;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   132
  _max_heap_byte_size = MaxHeapSize;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   133
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   134
  FLAG_SET_ERGO(size_t, MinHeapDeltaBytes, align_size_up(MinHeapDeltaBytes, _space_alignment));
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   135
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   136
  DEBUG_ONLY(CollectorPolicy::assert_flags();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
void CollectorPolicy::initialize_size_info() {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   140
  if (PrintGCDetails && Verbose) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   141
    gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT "  Initial heap "
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   142
      SIZE_FORMAT "  Maximum heap " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   143
      _min_heap_byte_size, _initial_heap_byte_size, _max_heap_byte_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   144
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   145
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   146
  DEBUG_ONLY(CollectorPolicy::assert_size_info();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   149
bool CollectorPolicy::use_should_clear_all_soft_refs(bool v) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   150
  bool result = _should_clear_all_soft_refs;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   151
  set_should_clear_all_soft_refs(false);
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   152
  return result;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   153
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
27687
3a6367d7110b 8064721: The card tables only ever need two covering regions
ehelin
parents: 26934
diff changeset
   155
GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap) {
3a6367d7110b 8064721: The card tables only ever need two covering regions
ehelin
parents: 26934
diff changeset
   156
  return new CardTableRS(whole_heap);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   159
void CollectorPolicy::cleared_all_soft_refs() {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   160
  // If near gc overhear limit, continue to clear SoftRefs.  SoftRefs may
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   161
  // have been cleared in the last collection but if the gc overhear
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   162
  // limit continues to be near, SoftRefs should still be cleared.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   163
  if (size_policy() != NULL) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   164
    _should_clear_all_soft_refs = size_policy()->gc_overhead_limit_near();
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   165
  }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   166
  _all_soft_refs_clear = true;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   167
}
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   168
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   169
size_t CollectorPolicy::compute_heap_alignment() {
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   170
  // The card marking array and the offset arrays for old generations are
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   171
  // committed in os pages as well. Make sure they are entirely full (to
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   172
  // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   173
  // byte entry and the os page size is 4096, the maximum heap size should
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   174
  // be 512*4096 = 2MB aligned.
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   175
22548
d54e4339811f 8031776: Remove the unnecessary enum GenRemSet::Name
ehelin
parents: 21567
diff changeset
   176
  size_t alignment = GenRemSet::max_alignment_constraint();
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   177
25943
fdb79c13bd3b 8034056: assert(_heap_alignment >= _space_alignment) failed: heap_alignment less than space_alignment
jmasa
parents: 25485
diff changeset
   178
  if (UseLargePages) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   179
      // In presence of large pages we have to make sure that our
25943
fdb79c13bd3b 8034056: assert(_heap_alignment >= _space_alignment) failed: heap_alignment less than space_alignment
jmasa
parents: 25485
diff changeset
   180
      // alignment is large page aware.
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   181
      alignment = lcm(os::large_page_size(), alignment);
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   182
  }
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   183
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   184
  return alignment;
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   185
}
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   186
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   187
// GenCollectorPolicy methods
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   189
GenCollectorPolicy::GenCollectorPolicy() :
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   190
    _min_young_size(0),
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   191
    _initial_young_size(0),
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   192
    _max_young_size(0),
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   193
    _min_old_size(0),
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   194
    _initial_old_size(0),
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   195
    _max_old_size(0),
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   196
    _gen_alignment(0),
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   197
    _young_gen_spec(NULL),
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   198
    _old_gen_spec(NULL)
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   199
{}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   200
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   201
size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   202
  return align_size_down_bounded(base_size / (NewRatio + 1), _gen_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   203
}
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   204
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   205
size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   206
                                                 size_t maximum_size) {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   207
  size_t max_minus = maximum_size - _gen_alignment;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   208
  return desired_size < max_minus ? desired_size : max_minus;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   209
}
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   210
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   211
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
                                                size_t init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
                                                size_t init_survivor_size) {
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21559
diff changeset
   215
  const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  _size_policy = new AdaptiveSizePolicy(init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
                                        init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
                                        init_survivor_size,
15748
66d805061d7a 8007764: Wrong initialized value of max_gc_pause_sec for an instance of class AdaptiveSizePolicy
tamao
parents: 15497
diff changeset
   219
                                        max_gc_pause_sec,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
                                        GCTimeRatio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   223
size_t GenCollectorPolicy::young_gen_size_lower_bound() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   224
  // The young generation must be aligned and have room for eden + two survivors
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   225
  return align_size_up(3 * _space_alignment, _gen_alignment);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   226
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   227
32362
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   228
size_t GenCollectorPolicy::old_gen_size_lower_bound() {
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   229
  return align_size_up(_space_alignment, _gen_alignment);
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   230
}
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   231
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   232
#ifdef ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   233
void GenCollectorPolicy::assert_flags() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   234
  CollectorPolicy::assert_flags();
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   235
  assert(NewSize >= _min_young_size, "Ergonomics decided on a too small young gen size");
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   236
  assert(NewSize <= MaxNewSize, "Ergonomics decided on incompatible initial and maximum young gen sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   237
  assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young gen and heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   238
  assert(NewSize % _gen_alignment == 0, "NewSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   239
  assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize % _gen_alignment == 0, "MaxNewSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   240
  assert(OldSize + NewSize <= MaxHeapSize, "Ergonomics decided on incompatible generation and heap sizes");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   241
  assert(OldSize % _gen_alignment == 0, "OldSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   242
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   243
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   244
void GenCollectorPolicy::assert_size_info() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   245
  CollectorPolicy::assert_size_info();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   246
  // GenCollectorPolicy::initialize_size_info may update the MaxNewSize
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   247
  assert(MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young and heap sizes");
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   248
  assert(NewSize == _initial_young_size, "Discrepancy between NewSize flag and local storage");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   249
  assert(MaxNewSize == _max_young_size, "Discrepancy between MaxNewSize flag and local storage");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   250
  assert(OldSize == _initial_old_size, "Discrepancy between OldSize flag and local storage");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   251
  assert(_min_young_size <= _initial_young_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   252
  assert(_initial_young_size <= _max_young_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   253
  assert(_min_young_size % _gen_alignment == 0, "_min_young_size alignment");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   254
  assert(_initial_young_size % _gen_alignment == 0, "_initial_young_size alignment");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   255
  assert(_max_young_size % _gen_alignment == 0, "_max_young_size alignment");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   256
  assert(_min_young_size <= bound_minus_alignment(_min_young_size, _min_heap_byte_size),
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   257
      "Ergonomics made minimum young generation larger than minimum heap");
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   258
  assert(_initial_young_size <=  bound_minus_alignment(_initial_young_size, _initial_heap_byte_size),
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   259
      "Ergonomics made initial young generation larger than initial heap");
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   260
  assert(_max_young_size <= bound_minus_alignment(_max_young_size, _max_heap_byte_size),
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   261
      "Ergonomics made maximum young generation lager than maximum heap");
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   262
  assert(_min_old_size <= _initial_old_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   263
  assert(_initial_old_size <= _max_old_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   264
  assert(_max_old_size % _gen_alignment == 0, "_max_old_size alignment");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   265
  assert(_initial_old_size % _gen_alignment == 0, "_initial_old_size alignment");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   266
  assert(_max_heap_byte_size <= (_max_young_size + _max_old_size), "Total maximum heap sizes must be sum of generation maximum sizes");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   267
  assert(_min_young_size + _min_old_size <= _min_heap_byte_size, "Minimum generation sizes exceed minimum heap size");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   268
  assert(_initial_young_size + _initial_old_size == _initial_heap_byte_size, "Initial generation sizes should match initial heap size");
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   269
  assert(_max_young_size + _max_old_size == _max_heap_byte_size, "Maximum generation sizes should match maximum heap size");
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   270
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   271
#endif // ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   272
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
void GenCollectorPolicy::initialize_flags() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  CollectorPolicy::initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   276
  assert(_gen_alignment != 0, "Generation alignment not set up properly");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   277
  assert(_heap_alignment >= _gen_alignment,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   278
         "heap_alignment: " SIZE_FORMAT " less than gen_alignment: " SIZE_FORMAT,
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   279
         _heap_alignment, _gen_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   280
  assert(_gen_alignment % _space_alignment == 0,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   281
         "gen_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   282
         _gen_alignment, _space_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   283
  assert(_heap_alignment % _gen_alignment == 0,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   284
         "heap_alignment: " SIZE_FORMAT " not aligned by gen_alignment: " SIZE_FORMAT,
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
   285
         _heap_alignment, _gen_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   286
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   287
  // All generational heaps have a youngest gen; handle those flags here
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   289
  // Make sure the heap is large enough for two generations
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   290
  size_t smallest_new_size = young_gen_size_lower_bound();
32362
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   291
  size_t smallest_heap_size = align_size_up(smallest_new_size + old_gen_size_lower_bound(),
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   292
                                           _heap_alignment);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   293
  if (MaxHeapSize < smallest_heap_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   294
    FLAG_SET_ERGO(size_t, MaxHeapSize, smallest_heap_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   295
    _max_heap_byte_size = MaxHeapSize;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   296
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   297
  // If needed, synchronize _min_heap_byte size and _initial_heap_byte_size
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   298
  if (_min_heap_byte_size < smallest_heap_size) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   299
    _min_heap_byte_size = smallest_heap_size;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   300
    if (InitialHeapSize < _min_heap_byte_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   301
      FLAG_SET_ERGO(size_t, InitialHeapSize, smallest_heap_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   302
      _initial_heap_byte_size = smallest_heap_size;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   303
    }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   304
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   305
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   306
  // Make sure NewSize allows an old generation to fit even if set on the command line
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   307
  if (FLAG_IS_CMDLINE(NewSize) && NewSize >= _initial_heap_byte_size) {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   308
    warning("NewSize was set larger than initial heap size, will use initial heap size.");
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   309
    NewSize = bound_minus_alignment(NewSize, _initial_heap_byte_size);
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   310
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   311
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   312
  // Now take the actual NewSize into account. We will silently increase NewSize
23224
b156569bc190 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line
sjohanss
parents: 22776
diff changeset
   313
  // if the user specified a smaller or unaligned value.
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   314
  size_t bounded_new_size = bound_minus_alignment(NewSize, MaxHeapSize);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   315
  bounded_new_size = MAX2(smallest_new_size, (size_t)align_size_down(bounded_new_size, _gen_alignment));
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   316
  if (bounded_new_size != NewSize) {
23224
b156569bc190 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line
sjohanss
parents: 22776
diff changeset
   317
    // Do not use FLAG_SET_ERGO to update NewSize here, since this will override
b156569bc190 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line
sjohanss
parents: 22776
diff changeset
   318
    // if NewSize was set on the command line or not. This information is needed
b156569bc190 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line
sjohanss
parents: 22776
diff changeset
   319
    // later when setting the initial and minimum young generation size.
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   320
    NewSize = bounded_new_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   322
  _min_young_size = smallest_new_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   323
  _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   324
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   325
  if (!FLAG_IS_DEFAULT(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   326
    if (MaxNewSize >= MaxHeapSize) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   327
      // Make sure there is room for an old generation
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   328
      size_t smaller_max_new_size = MaxHeapSize - _gen_alignment;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   329
      if (FLAG_IS_CMDLINE(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   330
        warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or greater than the entire "
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   331
                "heap (" SIZE_FORMAT "k).  A new max generation size of " SIZE_FORMAT "k will be used.",
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   332
                MaxNewSize/K, MaxHeapSize/K, smaller_max_new_size/K);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   333
      }
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   334
      FLAG_SET_ERGO(size_t, MaxNewSize, smaller_max_new_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   335
      if (NewSize > MaxNewSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   336
        FLAG_SET_ERGO(size_t, NewSize, MaxNewSize);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   337
        _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   338
      }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   339
    } else if (MaxNewSize < _initial_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   340
      FLAG_SET_ERGO(size_t, MaxNewSize, _initial_young_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   341
    } else if (!is_size_aligned(MaxNewSize, _gen_alignment)) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   342
      FLAG_SET_ERGO(size_t, MaxNewSize, align_size_down(MaxNewSize, _gen_alignment));
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   343
    }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   344
    _max_young_size = MaxNewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   345
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   347
  if (NewSize > MaxNewSize) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   348
    // At this point this should only happen if the user specifies a large NewSize and/or
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   349
    // a small (but not too small) MaxNewSize.
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   350
    if (FLAG_IS_CMDLINE(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   351
      warning("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). "
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   352
              "A new max generation size of " SIZE_FORMAT "k will be used.",
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   353
              NewSize/K, MaxNewSize/K, NewSize/K);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   354
    }
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   355
    FLAG_SET_ERGO(size_t, MaxNewSize, NewSize);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   356
    _max_young_size = MaxNewSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  }
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21559
diff changeset
   358
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  if (SurvivorRatio < 1 || NewRatio < 1) {
20399
d9bb551bf53d 8025854: Use "young gen" instead of "eden"
jwilhelm
parents: 20398
diff changeset
   360
    vm_exit_during_initialization("Invalid young gen ratio specified");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   362
32362
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   363
  OldSize = MAX2(OldSize, old_gen_size_lower_bound());
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   364
  if (!is_size_aligned(OldSize, _gen_alignment)) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   365
    // Setting OldSize directly to preserve information about the possible
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   366
    // setting of OldSize on the command line.
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   367
    OldSize = align_size_down(OldSize, _gen_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   368
  }
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   369
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   370
  if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(MaxHeapSize)) {
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   371
    // NewRatio will be used later to set the young generation size so we use
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   372
    // it to calculate how big the heap should be based on the requested OldSize
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   373
    // and NewRatio.
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   374
    assert(NewRatio > 0, "NewRatio should have been set up earlier");
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   375
    size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   376
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   377
    calculated_heapsize = align_size_up(calculated_heapsize, _heap_alignment);
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   378
    FLAG_SET_ERGO(size_t, MaxHeapSize, calculated_heapsize);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   379
    _max_heap_byte_size = MaxHeapSize;
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   380
    FLAG_SET_ERGO(size_t, InitialHeapSize, calculated_heapsize);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   381
    _initial_heap_byte_size = InitialHeapSize;
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   382
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   384
  // Adjust NewSize and OldSize or MaxHeapSize to match each other
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   385
  if (NewSize + OldSize > MaxHeapSize) {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   386
    if (_max_heap_size_cmdline) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   387
      // Somebody has set a maximum heap size with the intention that we should not
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   388
      // exceed it. Adjust New/OldSize as necessary.
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   389
      size_t calculated_size = NewSize + OldSize;
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   390
      double shrink_factor = (double) MaxHeapSize / calculated_size;
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   391
      size_t smaller_new_size = align_size_down((size_t)(NewSize * shrink_factor), _gen_alignment);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   392
      FLAG_SET_ERGO(size_t, NewSize, MAX2(young_gen_size_lower_bound(), smaller_new_size));
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   393
      _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   394
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   395
      // OldSize is already aligned because above we aligned MaxHeapSize to
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   396
      // _heap_alignment, and we just made sure that NewSize is aligned to
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   397
      // _gen_alignment. In initialize_flags() we verified that _heap_alignment
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   398
      // is a multiple of _gen_alignment.
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   399
      FLAG_SET_ERGO(size_t, OldSize, MaxHeapSize - NewSize);
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   400
    } else {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   401
      FLAG_SET_ERGO(size_t, MaxHeapSize, align_size_up(NewSize + OldSize, _heap_alignment));
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   402
      _max_heap_byte_size = MaxHeapSize;
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   403
    }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   404
  }
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   405
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   406
  // Update NewSize, if possible, to avoid sizing the young gen too small when only
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   407
  // OldSize is set on the command line.
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   408
  if (FLAG_IS_CMDLINE(OldSize) && !FLAG_IS_CMDLINE(NewSize)) {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   409
    if (OldSize < _initial_heap_byte_size) {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   410
      size_t new_size = _initial_heap_byte_size - OldSize;
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   411
      // Need to compare against the flag value for max since _max_young_size
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   412
      // might not have been set yet.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   413
      if (new_size >= _min_young_size && new_size <= MaxNewSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   414
        FLAG_SET_ERGO(size_t, NewSize, new_size);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   415
        _initial_young_size = NewSize;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   416
      }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   417
    }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   418
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   419
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  always_do_update_barrier = UseConcMarkSweepGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   422
  DEBUG_ONLY(GenCollectorPolicy::assert_flags();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   425
// Values set on the command line win over any ergonomically
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   426
// set command line parameters.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   427
// Ergonomic choice of parameters are done before this
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   428
// method is called.  Values for command line parameters such as NewSize
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   429
// and MaxNewSize feed those ergonomic choices into this method.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   430
// This method makes the final generation sizings consistent with
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   431
// themselves and with overall heap sizings.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   432
// In the absence of explicitly set command line flags, policies
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   433
// such as the use of NewRatio are used to size the generation.
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   434
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   435
// Minimum sizes of the generations may be different than
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   436
// the initial sizes.  An inconsistency is permitted here
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   437
// in the total size that can be specified explicitly by
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   438
// command line specification of OldSize and NewSize and
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   439
// also a command line specification of -Xms.  Issue a warning
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   440
// but allow the values to pass.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
void GenCollectorPolicy::initialize_size_info() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  CollectorPolicy::initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   444
  _initial_young_size = NewSize;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   445
  _max_young_size = MaxNewSize;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   446
  _initial_old_size = OldSize;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   447
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   448
  // Determine maximum size of the young generation.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   449
24940
c2b4c8e32c2f 8026396: Remove information duplication in the collector policy
jwilhelm
parents: 24424
diff changeset
   450
  if (FLAG_IS_DEFAULT(MaxNewSize)) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   451
    _max_young_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   452
    // Bound the maximum size by NewSize below (since it historically
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    // would have been NewSize and because the NewRatio calculation could
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    // yield a size that is too small) and bound it by MaxNewSize above.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   455
    // Ergonomics plays here by previously calculating the desired
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   456
    // NewSize and MaxNewSize.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   457
    _max_young_size = MIN2(MAX2(_max_young_size, _initial_young_size), MaxNewSize);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   458
  }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   459
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   460
  // Given the maximum young size, determine the initial and
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   461
  // minimum young sizes.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   462
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   463
  if (_max_heap_byte_size == _initial_heap_byte_size) {
24940
c2b4c8e32c2f 8026396: Remove information duplication in the collector policy
jwilhelm
parents: 24424
diff changeset
   464
    // The maximum and initial heap sizes are the same so the generation's
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   465
    // initial size must be the same as it maximum size. Use NewSize as the
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   466
    // size if set on command line.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   467
    _max_young_size = FLAG_IS_CMDLINE(NewSize) ? NewSize : _max_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   468
    _initial_young_size = _max_young_size;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   469
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   470
    // Also update the minimum size if min == initial == max.
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   471
    if (_max_heap_byte_size == _min_heap_byte_size) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   472
      _min_young_size = _max_young_size;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   473
    }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   474
  } else {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   475
    if (FLAG_IS_CMDLINE(NewSize)) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   476
      // If NewSize is set on the command line, we should use it as
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   477
      // the initial size, but make sure it is within the heap bounds.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   478
      _initial_young_size =
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   479
        MIN2(_max_young_size, bound_minus_alignment(NewSize, _initial_heap_byte_size));
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   480
      _min_young_size = bound_minus_alignment(_initial_young_size, _min_heap_byte_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   481
    } else {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   482
      // For the case where NewSize is not set on the command line, use
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   483
      // NewRatio to size the initial generation size. Use the current
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   484
      // NewSize as the floor, because if NewRatio is overly large, the resulting
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   485
      // size can be too small.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   486
      _initial_young_size =
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   487
        MIN2(_max_young_size, MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize));
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   488
    }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   489
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   490
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   491
  if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   492
    gclog_or_tty->print_cr("1: Minimum young " SIZE_FORMAT "  Initial young "
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   493
      SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   494
      _min_young_size, _initial_young_size, _max_young_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   495
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   496
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   497
  // At this point the minimum, initial and maximum sizes
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   498
  // of the overall heap and of the young generation have been determined.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   499
  // The maximum old size can be determined from the maximum young
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   500
  // and maximum heap size since no explicit flags exist
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   501
  // for setting the old generation maximum.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   502
  _max_old_size = MAX2(_max_heap_byte_size - _max_young_size, _gen_alignment);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   503
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   504
  // If no explicit command line flag has been set for the
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   505
  // old generation size, use what is left.
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   506
  if (!FLAG_IS_CMDLINE(OldSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   507
    // The user has not specified any value but the ergonomics
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   508
    // may have chosen a value (which may or may not be consistent
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   509
    // with the overall heap size).  In either case make
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   510
    // the minimum, maximum and initial sizes consistent
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   511
    // with the young sizes and the overall heap sizes.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   512
    _min_old_size = _gen_alignment;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   513
    _initial_old_size = MIN2(_max_old_size, MAX2(_initial_heap_byte_size - _initial_young_size, _min_old_size));
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   514
    // _max_old_size has already been made consistent above.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   515
  } else {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   516
    // OldSize has been explicitly set on the command line. Use it
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   517
    // for the initial size but make sure the minimum allow a young
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   518
    // generation to fit as well.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   519
    // If the user has explicitly set an OldSize that is inconsistent
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   520
    // with other command line flags, issue a warning.
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   521
    // The generation minimums and the overall heap minimum should
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   522
    // be within one generation alignment.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   523
    if (_initial_old_size > _max_old_size) {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   524
      warning("Inconsistency between maximum heap size and maximum "
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   525
          "generation sizes: using maximum heap = " SIZE_FORMAT
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   526
          " -XX:OldSize flag is being ignored",
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   527
          _max_heap_byte_size);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   528
      _initial_old_size = _max_old_size;
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   529
    }
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   530
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   531
    _min_old_size = MIN2(_initial_old_size, _min_heap_byte_size - _min_young_size);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   532
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   533
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   534
  // The initial generation sizes should match the initial heap size,
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   535
  // if not issue a warning and resize the generations. This behavior
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   536
  // differs from JDK8 where the generation sizes have higher priority
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   537
  // than the initial heap size.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   538
  if ((_initial_old_size + _initial_young_size) != _initial_heap_byte_size) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   539
    warning("Inconsistency between generation sizes and heap size, resizing "
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   540
            "the generations to fit the heap.");
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   541
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   542
    size_t desired_young_size = _initial_heap_byte_size - _initial_old_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   543
    if (_initial_heap_byte_size < _initial_old_size) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   544
      // Old want all memory, use minimum for young and rest for old
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   545
      _initial_young_size = _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   546
      _initial_old_size = _initial_heap_byte_size - _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   547
    } else if (desired_young_size > _max_young_size) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   548
      // Need to increase both young and old generation
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   549
      _initial_young_size = _max_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   550
      _initial_old_size = _initial_heap_byte_size - _max_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   551
    } else if (desired_young_size < _min_young_size) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   552
      // Need to decrease both young and old generation
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   553
      _initial_young_size = _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   554
      _initial_old_size = _initial_heap_byte_size - _min_young_size;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   555
    } else {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   556
      // The young generation boundaries allow us to only update the
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   557
      // young generation.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   558
      _initial_young_size = desired_young_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    }
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   560
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   561
    if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   562
      gclog_or_tty->print_cr("2: Minimum young " SIZE_FORMAT "  Initial young "
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   563
        SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   564
        _min_young_size, _initial_young_size, _max_young_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   565
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  }
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   567
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   568
  // Write back to flags if necessary.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   569
  if (NewSize != _initial_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   570
    FLAG_SET_ERGO(size_t, NewSize, _initial_young_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   571
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   572
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   573
  if (MaxNewSize != _max_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   574
    FLAG_SET_ERGO(size_t, MaxNewSize, _max_young_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   575
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   576
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   577
  if (OldSize != _initial_old_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   578
    FLAG_SET_ERGO(size_t, OldSize, _initial_old_size);
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   579
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   580
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   581
  if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   582
    gclog_or_tty->print_cr("Minimum old " SIZE_FORMAT "  Initial old "
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   583
      SIZE_FORMAT "  Maximum old " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   584
      _min_old_size, _initial_old_size, _max_old_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   585
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   586
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   587
  DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
                                        bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
                                        bool* gc_overhead_limit_was_exceeded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  debug_only(gch->check_for_valid_allocation_state());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  assert(gch->no_gc_in_progress(), "Allocation during gc not allowed");
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   597
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   598
  // In general gc_overhead_limit_was_exceeded should be false so
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   599
  // set it so here and reset it to true only if the gc time
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   600
  // limit is being exceeded as checked below.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   601
  *gc_overhead_limit_was_exceeded = false;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   602
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   605
  // Loop until the allocation is satisfied, or unsatisfied after GC.
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 27898
diff changeset
   606
  for (uint try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   607
    HandleMark hm; // Discard any handles allocated in each iteration.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
    // First allocation attempt is lock-free.
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   610
    Generation *young = gch->young_gen();
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   611
    assert(young->supports_inline_contig_alloc(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
      "Otherwise, must do alloc within heap lock");
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   613
    if (young->should_allocate(size, is_tlab)) {
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   614
      result = young->par_allocate(size, is_tlab);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
    }
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 27898
diff changeset
   620
    uint gc_count_before;  // Read inside the Heap_lock locked region.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
      MutexLocker ml(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
      if (PrintGC && Verbose) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   624
        gclog_or_tty->print_cr("GenCollectorPolicy::mem_allocate_work:"
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   625
                               " attempting locked slow path allocation");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
      // Note that only large objects get a shot at being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
      // allocated in later generations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      bool first_only = ! should_try_older_generation_allocation(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
      result = gch->attempt_allocation(size, is_tlab, first_only);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
      if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
        if (is_tlab) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   639
          return NULL;  // Caller will retry allocating individual object.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
        if (!gch->is_maximal_no_gc()) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   642
          // Try and expand heap to satisfy request.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
          result = expand_heap_and_allocate(size, is_tlab);
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   644
          // Result could be null if we are out of space.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
          if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
            return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   650
        if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   651
          return NULL; // We didn't get to do a GC and we didn't get any memory.
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   652
        }
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   653
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
        // If this thread is not in a jni critical section, we stall
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
        // the requestor until the critical section has cleared and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
        // GC allowed. When the critical section clears, a GC is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
        // initiated by the last thread exiting the critical section; so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
        // we retry the allocation sequence from the beginning of the loop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
        // rather than causing more, now probably unnecessary, GC attempts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
        JavaThread* jthr = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
        if (!jthr->in_critical()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
          MutexUnlocker mul(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
          // Wait for JNI critical section to be exited
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
          GC_locker::stall_until_clear();
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   665
          gclocker_stalled_count += 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
          if (CheckJNICalls) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
            fatal("Possible deadlock due to allocating while"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
                  " in jni critical section");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
          return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
      // Read the gc count while the heap lock is held.
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 29794
diff changeset
   677
      gc_count_before = gch->total_collections();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21559
diff changeset
   680
    VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    if (op.prologue_succeeded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      result = op.result();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
      if (op.gc_locked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
         assert(result == NULL, "must be NULL if gc_locked() is true");
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   686
         continue;  // Retry and/or stall as necessary.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
      }
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   688
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   689
      // Allocation has failed and a collection
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   690
      // has been done.  If the gc time limit was exceeded the
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   691
      // this time, return NULL so that an out-of-memory
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   692
      // will be thrown.  Clear gc_overhead_limit_exceeded
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   693
      // so that the overhead exceeded does not persist.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   694
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   695
      const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded();
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   696
      const bool softrefs_clear = all_soft_refs_clear();
15959
9a29e0e3a633 6976528: PS: assert(!limit_exceeded || softrefs_clear) failed: Should have been cleared
jmasa
parents: 15748
diff changeset
   697
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   698
      if (limit_exceeded && softrefs_clear) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   699
        *gc_overhead_limit_was_exceeded = true;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   700
        size_policy()->set_gc_overhead_limit_exceeded(false);
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   701
        if (op.result() != NULL) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   702
          CollectedHeap::fill_with_object(op.result(), size);
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   703
        }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   704
        return NULL;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   705
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      assert(result == NULL || gch->is_in_reserved(result),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
             "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
      return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    // Give a warning if we seem to be looping forever.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    if ((QueuedAllocationWarningCount > 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
        (try_count % QueuedAllocationWarningCount == 0)) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   714
          warning("GenCollectorPolicy::mem_allocate_work retries %d times \n\t"
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24353
diff changeset
   715
                  " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
                                                       bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  HeapWord* result = NULL;
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   724
  Generation *old = gch->old_gen();
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   725
  if (old->should_allocate(size, is_tlab)) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   726
    result = old->expand_and_allocate(size, is_tlab);
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   727
  }
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   728
  if (result == NULL) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   729
    Generation *young = gch->young_gen();
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   730
    if (young->should_allocate(size, is_tlab)) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   731
      result = young->expand_and_allocate(size, is_tlab);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  assert(result == NULL || gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
                                                        bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  GCCauseSetter x(gch, GCCause::_allocation_failure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  assert(size != 0, "Precondition violated");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    // GC locker is active; instead of a collection we will attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    // to expand the heap, if there's room for expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    if (!gch->is_maximal_no_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
      result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    }
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   751
    return result;   // Could be null if we are out of space.
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   752
  } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    // Do an incremental collection.
31358
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   754
    gch->do_collection(false,                     // full
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   755
                       false,                     // clear_all_soft_refs
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   756
                       size,                      // size
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   757
                       is_tlab,                   // is_tlab
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   758
                       GenCollectedHeap::OldGen); // max_generation
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  } else {
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   760
    if (Verbose && PrintGCDetails) {
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   761
      gclog_or_tty->print(" :: Trying full because partial may fail :: ");
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   762
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    // Try a full collection; see delta for bug id 6266275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    // for the original code and why this has been simplified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    // with from-space allocation criteria modified and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    // such allocation moved out of the safepoint path.
31358
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   767
    gch->do_collection(true,                      // full
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   768
                       false,                     // clear_all_soft_refs
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   769
                       size,                      // size
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   770
                       is_tlab,                   // is_tlab
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   771
                       GenCollectedHeap::OldGen); // max_generation
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  // OK, collection failed, try expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  // If we reach this point, we're really out of memory. Try every trick
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  // we can to reclaim memory. Force collection of soft references. Force
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  // a complete compaction of the heap. Any additional methods for finding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  // free memory should be here, especially if they are expensive. If this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  // attempt fails, an OOM exception will be thrown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  {
31236
d4d3011aa98e 8080947: Add uint as a valid VM flag type
david
parents: 30764
diff changeset
   793
    UIntXFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
31358
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   795
    gch->do_collection(true,                      // full
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   796
                       true,                      // clear_all_soft_refs
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   797
                       size,                      // size
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   798
                       is_tlab,                   // is_tlab
693058672cc6 8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents: 31236
diff changeset
   799
                       GenCollectedHeap::OldGen); // max_generation
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   808
  assert(!should_clear_all_soft_refs(),
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   809
    "Flag should have been handled and cleared prior to this point");
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   810
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  // What else?  We might try synchronous finalization later.  If the total
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  // space available is large enough for the allocation, then a more
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  // complete compaction phase than we've tried so far might be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  // appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   818
MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   819
                                                 ClassLoaderData* loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   820
                                                 size_t word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   821
                                                 Metaspace::MetadataType mdtype) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   822
  uint loop_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   823
  uint gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   824
  uint full_gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   825
14291
c8e69e83977f 8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents: 13755
diff changeset
   826
  assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock");
c8e69e83977f 8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents: 13755
diff changeset
   827
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   828
  do {
26934
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   829
    MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   830
    if (result != NULL) {
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   831
      return result;
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   832
    }
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   833
13755
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   834
    if (GC_locker::is_active_and_needs_gc()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   835
      // If the GC_locker is active, just expand and allocate.
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   836
      // If that does not succeed, wait if this thread is not
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   837
      // in a critical section itself.
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   838
      result =
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   839
        loader_data->metaspace_non_null()->expand_and_allocate(word_size,
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   840
                                                               mdtype);
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   841
      if (result != NULL) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   842
        return result;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   843
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   844
      JavaThread* jthr = JavaThread::current();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   845
      if (!jthr->in_critical()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   846
        // Wait for JNI critical section to be exited
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   847
        GC_locker::stall_until_clear();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   848
        // The GC invoked by the last thread leaving the critical
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   849
        // section will be a young collection and a full collection
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   850
        // is (currently) needed for unloading classes so continue
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   851
        // to the next iteration to get a full GC.
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   852
        continue;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   853
      } else {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   854
        if (CheckJNICalls) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   855
          fatal("Possible deadlock due to allocating while"
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   856
                " in jni critical section");
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   857
        }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   858
        return NULL;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   859
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   860
    }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   861
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   862
    {  // Need lock to get self consistent gc_count's
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   863
      MutexLocker ml(Heap_lock);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   864
      gc_count      = Universe::heap()->total_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   865
      full_gc_count = Universe::heap()->total_full_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   866
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   867
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   868
    // Generate a VM operation
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   869
    VM_CollectForMetadataAllocation op(loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   870
                                       word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   871
                                       mdtype,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   872
                                       gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   873
                                       full_gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   874
                                       GCCause::_metadata_GC_threshold);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   875
    VMThread::execute(&op);
15086
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   876
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   877
    // If GC was locked out, try again. Check before checking success because the
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   878
    // prologue could have succeeded and the GC still have been locked out.
15086
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   879
    if (op.gc_locked()) {
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   880
      continue;
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   881
    }
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   882
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   883
    if (op.prologue_succeeded()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   884
      return op.result();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   885
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   886
    loop_count++;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   887
    if ((QueuedAllocationWarningCount > 0) &&
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   888
        (loop_count % QueuedAllocationWarningCount == 0)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   889
      warning("satisfy_failed_metadata_allocation() retries %d times \n\t"
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24353
diff changeset
   890
              " size=" SIZE_FORMAT, loop_count, word_size);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   891
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   892
  } while (true);  // Until a GC is done
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   893
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   894
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
// Return true if any of the following is true:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
// . the allocation won't fit into the current young gen heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
// . gc locker is occupied (jni critical section)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
// . heap memory is tight -- the most recent previous collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
//   was a full collection because a partial collection (would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
//   have) failed and is likely to fail again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
bool GenCollectorPolicy::should_try_older_generation_allocation(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
        size_t word_size) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  GenCollectedHeap* gch = GenCollectedHeap::heap();
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   904
  size_t young_capacity = gch->young_gen()->capacity_before_gc();
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   905
  return    (word_size > heap_word_size(young_capacity))
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 6465
diff changeset
   906
         || GC_locker::is_active_and_needs_gc()
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 6465
diff changeset
   907
         || gch->incremental_collection_failed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
// MarkSweepPolicy methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   915
void MarkSweepPolicy::initialize_alignments() {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   916
  _space_alignment = _gen_alignment = (size_t)Generation::GenGrain;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   917
  _heap_alignment = compute_heap_alignment();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
void MarkSweepPolicy::initialize_generations() {
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   921
  _young_gen_spec = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size, _gen_alignment);
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   922
  _old_gen_spec   = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size, _gen_alignment);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
void MarkSweepPolicy::initialize_gc_policy_counters() {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   926
  // Initialize the policy counters - 2 collectors, 3 generations.
27898
813ad96387b3 8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents: 27687
diff changeset
   927
  _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
}
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   929
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   930
/////////////// Unit tests ///////////////
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   931
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   932
#ifndef PRODUCT
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   933
// Testing that the NewSize flag is handled correct is hard because it
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   934
// depends on so many other configurable variables. This test only tries to
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   935
// verify that there are some basic rules for NewSize honored by the policies.
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   936
class TestGenCollectorPolicy {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   937
public:
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   938
  static void test_new_size() {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   939
    size_t flag_value;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   940
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   941
    save_flags();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   942
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   943
    // If NewSize is set on the command line, it should be used
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   944
    // for both min and initial young size if less than min heap.
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   945
    flag_value = 20 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   946
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   947
    FLAG_SET_CMDLINE(size_t, NewSize, flag_value);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   948
    verify_young_min(flag_value);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   949
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   950
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   951
    FLAG_SET_CMDLINE(size_t, NewSize, flag_value);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   952
    verify_young_initial(flag_value);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   953
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   954
    // If NewSize is set on command line, but is larger than the min
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   955
    // heap size, it should only be used for initial young size.
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   956
    flag_value = 80 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   957
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   958
    FLAG_SET_CMDLINE(size_t, NewSize, flag_value);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   959
    verify_young_initial(flag_value);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   960
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   961
    // If NewSize has been ergonomically set, the collector policy
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   962
    // should use it for min but calculate the initial young size
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   963
    // using NewRatio.
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   964
    flag_value = 20 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   965
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   966
    FLAG_SET_ERGO(size_t, NewSize, flag_value);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   967
    verify_young_min(flag_value);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   968
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   969
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   970
    FLAG_SET_ERGO(size_t, NewSize, flag_value);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   971
    verify_scaled_young_initial(InitialHeapSize);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   972
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   973
    restore_flags();
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   974
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   975
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   976
  static void test_old_size() {
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   977
    size_t flag_value;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   978
    size_t heap_alignment = CollectorPolicy::compute_heap_alignment();
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   979
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   980
    save_flags();
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   981
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   982
    // If OldSize is set on the command line, it should be used
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   983
    // for both min and initial old size if less than min heap.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   984
    flag_value = 20 * M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   985
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   986
    FLAG_SET_CMDLINE(size_t, OldSize, flag_value);
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   987
    verify_old_min(flag_value);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   988
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   989
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   990
    FLAG_SET_CMDLINE(size_t, OldSize, flag_value);
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   991
    // Calculate what we expect the flag to be.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   992
    size_t expected_old_initial = align_size_up(InitialHeapSize, heap_alignment) - MaxNewSize;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   993
    verify_old_initial(expected_old_initial);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   994
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   995
    // If MaxNewSize is large, the maximum OldSize will be less than
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   996
    // what's requested on the command line and it should be reset
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   997
    // ergonomically.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   998
    // We intentionally set MaxNewSize + OldSize > MaxHeapSize (see over_size).
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   999
    flag_value = 30 * M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1000
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1001
    FLAG_SET_CMDLINE(size_t, OldSize, flag_value);
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1002
    size_t over_size = 20*M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1003
    size_t new_size_value = align_size_up(MaxHeapSize, heap_alignment) - flag_value + over_size;
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1004
    FLAG_SET_CMDLINE(size_t, MaxNewSize, new_size_value);
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1005
    // Calculate what we expect the flag to be.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1006
    expected_old_initial = align_size_up(MaxHeapSize, heap_alignment) - MaxNewSize;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1007
    verify_old_initial(expected_old_initial);
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1008
    restore_flags();
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1009
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1010
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1011
  static void verify_young_min(size_t expected) {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1012
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1013
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1014
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1015
    assert(msp.min_young_size() <= expected, "%zu  > %zu", msp.min_young_size(), expected);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1016
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1017
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1018
  static void verify_young_initial(size_t expected) {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1019
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1020
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1021
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1022
    assert(msp.initial_young_size() == expected, "%zu != %zu", msp.initial_young_size(), expected);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1023
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1024
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1025
  static void verify_scaled_young_initial(size_t initial_heap_size) {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1026
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1027
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1028
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1029
    if (InitialHeapSize > initial_heap_size) {
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1030
      // InitialHeapSize was adapted by msp.initialize_all, e.g. due to alignment
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1031
      // caused by 64K page size.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1032
      initial_heap_size = InitialHeapSize;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1033
    }
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1034
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1035
    size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1036
    assert(msp.initial_young_size() == expected, "%zu != %zu", msp.initial_young_size(), expected);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1037
    assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1038
        "NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1039
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1040
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1041
  static void verify_old_min(size_t expected) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1042
    MarkSweepPolicy msp;
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1043
    msp.initialize_all();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1044
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1045
    assert(msp.min_old_size() <= expected, "%zu  > %zu", msp.min_old_size(), expected);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1046
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1047
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1048
  static void verify_old_initial(size_t expected) {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1049
    MarkSweepPolicy msp;
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1050
    msp.initialize_all();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1051
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32362
diff changeset
  1052
    assert(msp.initial_old_size() == expected, "%zu != %zu", msp.initial_old_size(), expected);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1053
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1054
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1055
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1056
private:
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1057
  static size_t original_InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1058
  static size_t original_MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1059
  static size_t original_MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1060
  static size_t original_MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1061
  static size_t original_NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1062
  static size_t original_OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1063
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1064
  static void set_basic_flag_values() {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1065
    FLAG_SET_ERGO(size_t, MaxHeapSize, 180 * M);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1066
    FLAG_SET_ERGO(size_t, InitialHeapSize, 100 * M);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1067
    FLAG_SET_ERGO(size_t, OldSize, 4 * M);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1068
    FLAG_SET_ERGO(size_t, NewSize, 1 * M);
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1069
    FLAG_SET_ERGO(size_t, MaxNewSize, 80 * M);
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1070
    Arguments::set_min_heap_size(40 * M);
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1071
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1072
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1073
  static void save_flags() {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1074
    original_InitialHeapSize   = InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1075
    original_MaxHeapSize       = MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1076
    original_MaxNewSize        = MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1077
    original_MinHeapDeltaBytes = MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1078
    original_NewSize           = NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1079
    original_OldSize           = OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1080
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1081
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1082
  static void restore_flags() {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1083
    InitialHeapSize   = original_InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1084
    MaxHeapSize       = original_MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1085
    MaxNewSize        = original_MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1086
    MinHeapDeltaBytes = original_MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1087
    NewSize           = original_NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1088
    OldSize           = original_OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1089
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1090
};
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1091
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1092
size_t TestGenCollectorPolicy::original_InitialHeapSize   = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1093
size_t TestGenCollectorPolicy::original_MaxHeapSize       = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1094
size_t TestGenCollectorPolicy::original_MaxNewSize        = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1095
size_t TestGenCollectorPolicy::original_MinHeapDeltaBytes = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1096
size_t TestGenCollectorPolicy::original_NewSize           = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1097
size_t TestGenCollectorPolicy::original_OldSize           = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1098
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1099
void TestNewSize_test() {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1100
  TestGenCollectorPolicy::test_new_size();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1101
}
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1102
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1103
void TestOldSize_test() {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1104
  TestGenCollectorPolicy::test_old_size();
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1105
}
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1106
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1107
#endif