hotspot/src/share/vm/gc/shared/collectorPolicy.cpp
author david
Thu, 04 Jun 2015 14:29:34 +0200
changeset 31236 d4d3011aa98e
parent 30764 fec48bf5a827
child 31358 693058672cc6
permissions -rw-r--r--
8080947: Add uint as a valid VM flag type Reviewed-by: brutisso, ddmitriev
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,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    81
         err_msg("heap_alignment: " SIZE_FORMAT " less than space_alignment: " SIZE_FORMAT,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    82
                 _heap_alignment, _space_alignment));
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    83
  assert(_heap_alignment % _space_alignment == 0,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    84
         err_msg("heap_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
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
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   228
#ifdef ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   229
void GenCollectorPolicy::assert_flags() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   230
  CollectorPolicy::assert_flags();
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   231
  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
   232
  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
   233
  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
   234
  assert(NewSize % _gen_alignment == 0, "NewSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   235
  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
   236
  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
   237
  assert(OldSize % _gen_alignment == 0, "OldSize alignment");
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   238
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   239
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   240
void GenCollectorPolicy::assert_size_info() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   241
  CollectorPolicy::assert_size_info();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   242
  // 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
   243
  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
   244
  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
   245
  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
   246
  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
   247
  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
   248
  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
   249
  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
   250
  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
   251
  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
   252
  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
   253
      "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
   254
  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
   255
      "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
   256
  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
   257
      "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
   258
  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
   259
  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
   260
  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
   261
  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
   262
  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
   263
  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
   264
  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
   265
  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
   266
}
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   267
#endif // ASSERT
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   268
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
void GenCollectorPolicy::initialize_flags() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  CollectorPolicy::initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   272
  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
   273
  assert(_heap_alignment >= _gen_alignment,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   274
         err_msg("heap_alignment: " SIZE_FORMAT " less than gen_alignment: " SIZE_FORMAT,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   275
                 _heap_alignment, _gen_alignment));
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   276
  assert(_gen_alignment % _space_alignment == 0,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   277
         err_msg("gen_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   278
                 _gen_alignment, _space_alignment));
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   279
  assert(_heap_alignment % _gen_alignment == 0,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   280
         err_msg("heap_alignment: " SIZE_FORMAT " not aligned by gen_alignment: " SIZE_FORMAT,
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   281
                 _heap_alignment, _gen_alignment));
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   282
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   283
  // All generational heaps have a youngest gen; handle those flags here
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   285
  // 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
   286
  size_t smallest_new_size = young_gen_size_lower_bound();
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   287
  size_t smallest_heap_size = align_size_up(smallest_new_size + align_size_up(_space_alignment, _gen_alignment),
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   288
                                           _heap_alignment);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   289
  if (MaxHeapSize < smallest_heap_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   290
    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
   291
    _max_heap_byte_size = MaxHeapSize;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   292
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   293
  // 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
   294
  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
   295
    _min_heap_byte_size = smallest_heap_size;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   296
    if (InitialHeapSize < _min_heap_byte_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   297
      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
   298
      _initial_heap_byte_size = smallest_heap_size;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   299
    }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   300
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   301
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   302
  // 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
   303
  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
   304
    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
   305
    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
   306
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   307
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   308
  // 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
   309
  // 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
   310
  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
   311
  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
   312
  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
   313
    // 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
   314
    // 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
   315
    // 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
   316
    NewSize = bounded_new_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   318
  _min_young_size = smallest_new_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   319
  _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   320
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   321
  if (!FLAG_IS_DEFAULT(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   322
    if (MaxNewSize >= MaxHeapSize) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   323
      // 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
   324
      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
   325
      if (FLAG_IS_CMDLINE(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   326
        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
   327
                "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
   328
                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
   329
      }
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   330
      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
   331
      if (NewSize > MaxNewSize) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   332
        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
   333
        _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   334
      }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   335
    } else if (MaxNewSize < _initial_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   336
      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
   337
    } 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
   338
      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
   339
    }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   340
    _max_young_size = MaxNewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   341
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   343
  if (NewSize > MaxNewSize) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   344
    // 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
   345
    // a small (but not too small) MaxNewSize.
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   346
    if (FLAG_IS_CMDLINE(MaxNewSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   347
      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
   348
              "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
   349
              NewSize/K, MaxNewSize/K, NewSize/K);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   350
    }
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   351
    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
   352
    _max_young_size = MaxNewSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  }
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21559
diff changeset
   354
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  if (SurvivorRatio < 1 || NewRatio < 1) {
20399
d9bb551bf53d 8025854: Use "young gen" instead of "eden"
jwilhelm
parents: 20398
diff changeset
   356
    vm_exit_during_initialization("Invalid young gen ratio specified");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   358
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   359
  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
   360
    // 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
   361
    // 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
   362
    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
   363
  }
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   364
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   365
  if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(MaxHeapSize)) {
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   366
    // 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
   367
    // 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
   368
    // and NewRatio.
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   369
    assert(NewRatio > 0, "NewRatio should have been set up earlier");
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   370
    size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   371
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   372
    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
   373
    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
   374
    _max_heap_byte_size = MaxHeapSize;
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   375
    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
   376
    _initial_heap_byte_size = InitialHeapSize;
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   377
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   379
  // 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
   380
  if (NewSize + OldSize > MaxHeapSize) {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   381
    if (_max_heap_size_cmdline) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   382
      // 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
   383
      // 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
   384
      size_t calculated_size = NewSize + OldSize;
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   385
      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
   386
      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
   387
      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
   388
      _initial_young_size = NewSize;
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   389
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   390
      // 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
   391
      // _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
   392
      // _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
   393
      // is a multiple of _gen_alignment.
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   394
      FLAG_SET_ERGO(size_t, OldSize, MaxHeapSize - NewSize);
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   395
    } else {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   396
      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
   397
      _max_heap_byte_size = MaxHeapSize;
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   398
    }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   399
  }
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   400
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   401
  // 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
   402
  // 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
   403
  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
   404
    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
   405
      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
   406
      // 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
   407
      // might not have been set yet.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   408
      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
   409
        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
   410
        _initial_young_size = NewSize;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   411
      }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   412
    }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   413
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   414
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  always_do_update_barrier = UseConcMarkSweepGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   417
  DEBUG_ONLY(GenCollectorPolicy::assert_flags();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   420
// 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
   421
// set command line parameters.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   422
// 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
   423
// 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
   424
// 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
   425
// 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
   426
// themselves and with overall heap sizings.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   427
// 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
   428
// such as the use of NewRatio are used to size the generation.
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   429
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   430
// Minimum sizes of the generations may be different than
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   431
// the initial sizes.  An inconsistency is permitted here
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   432
// in the total size that can be specified explicitly by
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   433
// command line specification of OldSize and NewSize and
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   434
// also a command line specification of -Xms.  Issue a warning
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   435
// but allow the values to pass.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
void GenCollectorPolicy::initialize_size_info() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  CollectorPolicy::initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   439
  _initial_young_size = NewSize;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   440
  _max_young_size = MaxNewSize;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   441
  _initial_old_size = OldSize;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   442
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   443
  // 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
   444
24940
c2b4c8e32c2f 8026396: Remove information duplication in the collector policy
jwilhelm
parents: 24424
diff changeset
   445
  if (FLAG_IS_DEFAULT(MaxNewSize)) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   446
    _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
   447
    // Bound the maximum size by NewSize below (since it historically
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
    // would have been NewSize and because the NewRatio calculation could
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    // 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
   450
    // 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
   451
    // NewSize and MaxNewSize.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   452
    _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
   453
  }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   454
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   455
  // 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
   456
  // minimum young sizes.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   457
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   458
  if (_max_heap_byte_size == _initial_heap_byte_size) {
24940
c2b4c8e32c2f 8026396: Remove information duplication in the collector policy
jwilhelm
parents: 24424
diff changeset
   459
    // 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
   460
    // 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
   461
    // size if set on command line.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   462
    _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
   463
    _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
   464
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   465
    // 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
   466
    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
   467
      _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
   468
    }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   469
  } else {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   470
    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
   471
      // 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
   472
      // 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
   473
      _initial_young_size =
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   474
        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
   475
      _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
   476
    } else {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   477
      // 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
   478
      // 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
   479
      // 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
   480
      // size can be too small.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   481
      _initial_young_size =
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   482
        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
   483
    }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   484
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   485
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   486
  if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   487
    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
   488
      SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   489
      _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
   490
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   491
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   492
  // 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
   493
  // 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
   494
  // 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
   495
  // 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
   496
  // for setting the old generation maximum.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   497
  _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
   498
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   499
  // 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
   500
  // 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
   501
  if (!FLAG_IS_CMDLINE(OldSize)) {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   502
    // 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
   503
    // 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
   504
    // 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
   505
    // 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
   506
    // 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
   507
    _min_old_size = _gen_alignment;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   508
    _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
   509
    // _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
   510
  } else {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   511
    // 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
   512
    // 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
   513
    // generation to fit as well.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   514
    // 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
   515
    // with other command line flags, issue a warning.
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   516
    // 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
   517
    // be within one generation alignment.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   518
    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
   519
      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
   520
          "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
   521
          " -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
   522
          _max_heap_byte_size);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   523
      _initial_old_size = _max_old_size;
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   524
    }
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   525
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   526
    _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
   527
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   528
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   529
  // 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
   530
  // 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
   531
  // 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
   532
  // than the initial heap size.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   533
  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
   534
    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
   535
            "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
   536
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   537
    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
   538
    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
   539
      // 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
   540
      _initial_young_size = _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   541
      _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
   542
    } 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
   543
      // 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
   544
      _initial_young_size = _max_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   545
      _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
   546
    } 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
   547
      // 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
   548
      _initial_young_size = _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   549
      _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
   550
    } else {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   551
      // 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
   552
      // young generation.
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   553
      _initial_young_size = desired_young_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    }
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   555
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   556
    if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   557
      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
   558
        SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   559
        _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
   560
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   562
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   563
  // Write back to flags if necessary.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   564
  if (NewSize != _initial_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   565
    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
   566
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   567
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   568
  if (MaxNewSize != _max_young_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   569
    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
   570
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   571
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   572
  if (OldSize != _initial_old_size) {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   573
    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
   574
  }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   575
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   576
  if (PrintGCDetails && Verbose) {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   577
    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
   578
      SIZE_FORMAT "  Maximum old " SIZE_FORMAT,
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   579
      _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
   580
  }
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   581
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   582
  DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
                                        bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
                                        bool* gc_overhead_limit_was_exceeded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  debug_only(gch->check_for_valid_allocation_state());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  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
   592
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   593
  // 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
   594
  // 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
   595
  // 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
   596
  *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
   597
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   600
  // Loop until the allocation is satisfied, or unsatisfied after GC.
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 27898
diff changeset
   601
  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
   602
    HandleMark hm; // Discard any handles allocated in each iteration.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    // First allocation attempt is lock-free.
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   605
    Generation *young = gch->young_gen();
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   606
    assert(young->supports_inline_contig_alloc(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
      "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
   608
    if (young->should_allocate(size, is_tlab)) {
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
   609
      result = young->par_allocate(size, is_tlab);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    }
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 27898
diff changeset
   615
    uint gc_count_before;  // Read inside the Heap_lock locked region.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
      MutexLocker ml(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
      if (PrintGC && Verbose) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   619
        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
   620
                               " attempting locked slow path allocation");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
      // Note that only large objects get a shot at being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
      // allocated in later generations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
      bool first_only = ! should_try_older_generation_allocation(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
      result = gch->attempt_allocation(size, is_tlab, first_only);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
        if (is_tlab) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   634
          return NULL;  // Caller will retry allocating individual object.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
        if (!gch->is_maximal_no_gc()) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   637
          // Try and expand heap to satisfy request.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
          result = expand_heap_and_allocate(size, is_tlab);
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   639
          // Result could be null if we are out of space.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
          if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
            return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   645
        if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   646
          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
   647
        }
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   648
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
        // If this thread is not in a jni critical section, we stall
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
        // the requestor until the critical section has cleared and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
        // GC allowed. When the critical section clears, a GC is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
        // initiated by the last thread exiting the critical section; so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
        // we retry the allocation sequence from the beginning of the loop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
        // rather than causing more, now probably unnecessary, GC attempts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
        JavaThread* jthr = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
        if (!jthr->in_critical()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
          MutexUnlocker mul(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
          // Wait for JNI critical section to be exited
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
          GC_locker::stall_until_clear();
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   660
          gclocker_stalled_count += 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
          if (CheckJNICalls) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
            fatal("Possible deadlock due to allocating while"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
                  " in jni critical section");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
          return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      // 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
   672
      gc_count_before = gch->total_collections();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21559
diff changeset
   675
    VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    if (op.prologue_succeeded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
      result = op.result();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
      if (op.gc_locked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
         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
   681
         continue;  // Retry and/or stall as necessary.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      }
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   683
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   684
      // 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
   685
      // 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
   686
      // 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
   687
      // 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
   688
      // 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
   689
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   690
      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
   691
      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
   692
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   693
      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
   694
        *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
   695
        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
   696
        if (op.result() != NULL) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   697
          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
   698
        }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   699
        return NULL;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   700
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
      assert(result == NULL || gch->is_in_reserved(result),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
             "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
      return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
    // Give a warning if we seem to be looping forever.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    if ((QueuedAllocationWarningCount > 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
        (try_count % QueuedAllocationWarningCount == 0)) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   709
          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
   710
                  " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
                                                       bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  HeapWord* result = NULL;
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   719
  Generation *old = gch->old_gen();
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   720
  if (old->should_allocate(size, is_tlab)) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   721
    result = old->expand_and_allocate(size, is_tlab);
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   722
  }
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   723
  if (result == NULL) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   724
    Generation *young = gch->young_gen();
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   725
    if (young->should_allocate(size, is_tlab)) {
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   726
      result = young->expand_and_allocate(size, is_tlab);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  assert(result == NULL || gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
                                                        bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  GCCauseSetter x(gch, GCCause::_allocation_failure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  assert(size != 0, "Precondition violated");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    // GC locker is active; instead of a collection we will attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    // to expand the heap, if there's room for expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
    if (!gch->is_maximal_no_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
      result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    }
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   746
    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
   747
  } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    // Do an incremental collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    gch->do_collection(false            /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
                       false            /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  } else {
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   755
    if (Verbose && PrintGCDetails) {
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   756
      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
   757
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    // Try a full collection; see delta for bug id 6266275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    // for the original code and why this has been simplified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    // with from-space allocation criteria modified and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    // such allocation moved out of the safepoint path.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    gch->do_collection(true             /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
                       false            /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  // OK, collection failed, try expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  // If we reach this point, we're really out of memory. Try every trick
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  // we can to reclaim memory. Force collection of soft references. Force
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  // a complete compaction of the heap. Any additional methods for finding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  // free memory should be here, especially if they are expensive. If this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  // attempt fails, an OOM exception will be thrown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  {
31236
d4d3011aa98e 8080947: Add uint as a valid VM flag type
david
parents: 30764
diff changeset
   788
    UIntXFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    gch->do_collection(true             /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
                       true             /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   803
  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
   804
    "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
   805
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  // What else?  We might try synchronous finalization later.  If the total
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  // space available is large enough for the allocation, then a more
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  // complete compaction phase than we've tried so far might be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  // appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   813
MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   814
                                                 ClassLoaderData* loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   815
                                                 size_t word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   816
                                                 Metaspace::MetadataType mdtype) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   817
  uint loop_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   818
  uint gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   819
  uint full_gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   820
14291
c8e69e83977f 8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents: 13755
diff changeset
   821
  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
   822
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   823
  do {
26934
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   824
    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
   825
    if (result != NULL) {
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   826
      return result;
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   827
    }
8a3682c071be 8058963: CollectorPolicy::satisfy_failed_metadata_allocation can avoid some safepoints
ehelin
parents: 25957
diff changeset
   828
13755
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   829
    if (GC_locker::is_active_and_needs_gc()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   830
      // 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
   831
      // 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
   832
      // in a critical section itself.
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   833
      result =
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   834
        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
   835
                                                               mdtype);
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   836
      if (result != NULL) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   837
        return result;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   838
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   839
      JavaThread* jthr = JavaThread::current();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   840
      if (!jthr->in_critical()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   841
        // Wait for JNI critical section to be exited
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   842
        GC_locker::stall_until_clear();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   843
        // 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
   844
        // 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
   845
        // is (currently) needed for unloading classes so continue
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   846
        // 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
   847
        continue;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   848
      } else {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   849
        if (CheckJNICalls) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   850
          fatal("Possible deadlock due to allocating while"
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   851
                " in jni critical section");
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   852
        }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   853
        return NULL;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   854
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   855
    }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   856
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   857
    {  // 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
   858
      MutexLocker ml(Heap_lock);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   859
      gc_count      = Universe::heap()->total_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   860
      full_gc_count = Universe::heap()->total_full_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   861
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   862
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   863
    // Generate a VM operation
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   864
    VM_CollectForMetadataAllocation op(loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   865
                                       word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   866
                                       mdtype,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   867
                                       gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   868
                                       full_gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   869
                                       GCCause::_metadata_GC_threshold);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   870
    VMThread::execute(&op);
15086
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   871
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   872
    // 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
   873
    // 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
   874
    if (op.gc_locked()) {
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   875
      continue;
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   876
    }
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   877
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   878
    if (op.prologue_succeeded()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   879
      return op.result();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   880
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   881
    loop_count++;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   882
    if ((QueuedAllocationWarningCount > 0) &&
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   883
        (loop_count % QueuedAllocationWarningCount == 0)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   884
      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
   885
              " size=" SIZE_FORMAT, loop_count, word_size);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   886
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   887
  } while (true);  // Until a GC is done
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   888
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   889
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
// Return true if any of the following is true:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
// . the allocation won't fit into the current young gen heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
// . gc locker is occupied (jni critical section)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
// . heap memory is tight -- the most recent previous collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
//   was a full collection because a partial collection (would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
//   have) failed and is likely to fail again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
bool GenCollectorPolicy::should_try_older_generation_allocation(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
        size_t word_size) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  GenCollectedHeap* gch = GenCollectedHeap::heap();
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29207
diff changeset
   899
  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
   900
  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
   901
         || 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
   902
         || gch->incremental_collection_failed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
// MarkSweepPolicy methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   910
void MarkSweepPolicy::initialize_alignments() {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   911
  _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
   912
  _heap_alignment = compute_heap_alignment();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
void MarkSweepPolicy::initialize_generations() {
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29697
diff changeset
   916
  _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
   917
  _old_gen_spec   = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size, _gen_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_gc_policy_counters() {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22548
diff changeset
   921
  // Initialize the policy counters - 2 collectors, 3 generations.
27898
813ad96387b3 8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents: 27687
diff changeset
   922
  _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
}
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   924
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   925
/////////////// Unit tests ///////////////
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   926
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   927
#ifndef PRODUCT
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   928
// 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
   929
// 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
   930
// 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
   931
class TestGenCollectorPolicy {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   932
public:
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   933
  static void test_new_size() {
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   934
    size_t flag_value;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   935
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   936
    save_flags();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   937
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   938
    // 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
   939
    // 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
   940
    flag_value = 20 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   941
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   942
    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
   943
    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
   944
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   945
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   946
    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
   947
    verify_young_initial(flag_value);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   948
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   949
    // 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
   950
    // 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
   951
    flag_value = 80 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   952
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   953
    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
   954
    verify_young_initial(flag_value);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   955
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   956
    // 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
   957
    // 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
   958
    // using NewRatio.
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   959
    flag_value = 20 * M;
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   960
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   961
    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
   962
    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
   963
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   964
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   965
    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
   966
    verify_scaled_young_initial(InitialHeapSize);
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   967
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
   968
    restore_flags();
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   969
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   970
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   971
  static void test_old_size() {
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   972
    size_t flag_value;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   973
    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
   974
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   975
    save_flags();
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
   976
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   977
    // 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
   978
    // 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
   979
    flag_value = 20 * M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   980
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   981
    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
   982
    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
   983
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   984
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   985
    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
   986
    // 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
   987
    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
   988
    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
   989
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   990
    // 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
   991
    // 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
   992
    // ergonomically.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   993
    // 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
   994
    flag_value = 30 * M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   995
    set_basic_flag_values();
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
   996
    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
   997
    size_t over_size = 20*M;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
   998
    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
   999
    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
  1000
    // 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
  1001
    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
  1002
    verify_old_initial(expected_old_initial);
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1003
    restore_flags();
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1004
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1005
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1006
  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
  1007
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1008
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1009
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1010
    assert(msp.min_young_size() <= expected, err_msg("%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
  1011
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1012
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1013
  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
  1014
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1015
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1016
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1017
    assert(msp.initial_young_size() == expected, err_msg("%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
  1018
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1019
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1020
  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
  1021
    MarkSweepPolicy msp;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1022
    msp.initialize_all();
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1023
29207
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1024
    if (InitialHeapSize > initial_heap_size) {
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1025
      // 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
  1026
      // caused by 64K page size.
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1027
      initial_heap_size = InitialHeapSize;
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1028
    }
c5b52635f690 8071822: [TEST_BUG] Adapt collectorPolicy internal tests to support 64K pages
goetz
parents: 29078
diff changeset
  1029
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1030
    size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1031
    assert(msp.initial_young_size() == expected, err_msg("%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
  1032
    assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1033
        err_msg("NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize));
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1034
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1035
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1036
  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
  1037
    MarkSweepPolicy msp;
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1038
    msp.initialize_all();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1039
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1040
    assert(msp.min_old_size() <= expected, err_msg("%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
  1041
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1042
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1043
  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
  1044
    MarkSweepPolicy msp;
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1045
    msp.initialize_all();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1046
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24940
diff changeset
  1047
    assert(msp.initial_old_size() == expected, err_msg("%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
  1048
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1049
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1050
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1051
private:
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1052
  static size_t original_InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1053
  static size_t original_MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1054
  static size_t original_MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1055
  static size_t original_MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1056
  static size_t original_NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1057
  static size_t original_OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1058
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1059
  static void set_basic_flag_values() {
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29684
diff changeset
  1060
    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
  1061
    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
  1062
    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
  1063
    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
  1064
    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
  1065
    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
  1066
  }
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1067
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1068
  static void save_flags() {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1069
    original_InitialHeapSize   = InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1070
    original_MaxHeapSize       = MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1071
    original_MaxNewSize        = MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1072
    original_MinHeapDeltaBytes = MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1073
    original_NewSize           = NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1074
    original_OldSize           = OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1075
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1076
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1077
  static void restore_flags() {
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1078
    InitialHeapSize   = original_InitialHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1079
    MaxHeapSize       = original_MaxHeapSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1080
    MaxNewSize        = original_MaxNewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1081
    MinHeapDeltaBytes = original_MinHeapDeltaBytes;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1082
    NewSize           = original_NewSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1083
    OldSize           = original_OldSize;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1084
  }
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1085
};
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1086
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1087
size_t TestGenCollectorPolicy::original_InitialHeapSize   = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1088
size_t TestGenCollectorPolicy::original_MaxHeapSize       = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1089
size_t TestGenCollectorPolicy::original_MaxNewSize        = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1090
size_t TestGenCollectorPolicy::original_MinHeapDeltaBytes = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1091
size_t TestGenCollectorPolicy::original_NewSize           = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1092
size_t TestGenCollectorPolicy::original_OldSize           = 0;
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1093
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1094
void TestNewSize_test() {
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1095
  TestGenCollectorPolicy::test_new_size();
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1096
}
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1097
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1098
void TestOldSize_test() {
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 23224
diff changeset
  1099
  TestGenCollectorPolicy::test_old_size();
22776
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1100
}
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1101
d99c54477401 8033426: Scale initial NewSize using NewRatio if not set on command line
sjohanss
parents: 22551
diff changeset
  1102
#endif