hotspot/src/share/vm/memory/collectorPolicy.cpp
author stefank
Mon, 07 Oct 2013 15:51:08 +0200
changeset 20406 934f0b12daa9
parent 20399 d9bb551bf53d
child 21558 8dcd5451cdca
permissions -rw-r--r--
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces Reviewed-by: brutisso, jmasa, coleenp
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
     2
 * Copyright (c) 2001, 2013, 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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    26
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    27
#include "gc_implementation/shared/gcPolicyCounters.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    28
#include "gc_implementation/shared/vmGCOperations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    29
#include "memory/cardTableRS.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    30
#include "memory/collectorPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    31
#include "memory/gcLocker.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    32
#include "memory/genCollectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    33
#include "memory/generationSpec.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    34
#include "memory/space.hpp"
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"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15091
diff changeset
    43
#if INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    44
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    45
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15091
diff changeset
    46
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// CollectorPolicy methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
void CollectorPolicy::initialize_flags() {
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    51
  assert(_max_alignment >= _min_alignment,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    52
         err_msg("max_alignment: " SIZE_FORMAT " less than min_alignment: " SIZE_FORMAT,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    53
                 _max_alignment, _min_alignment));
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    54
  assert(_max_alignment % _min_alignment == 0,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    55
         err_msg("max_alignment: " SIZE_FORMAT " not aligned by min_alignment: " SIZE_FORMAT,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    56
                 _max_alignment, _min_alignment));
17320
e7e94e2542e4 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents: 17031
diff changeset
    57
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    58
  if (MaxHeapSize < InitialHeapSize) {
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    59
    vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    60
  }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    61
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    62
  MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, _min_alignment);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
void CollectorPolicy::initialize_size_info() {
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
    66
  // User inputs from -mx and ms must be aligned
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    67
  _min_heap_byte_size = align_size_up(Arguments::min_heap_size(), _min_alignment);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    68
  _initial_heap_byte_size = align_size_up(InitialHeapSize, _min_alignment);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    69
  _max_heap_byte_size = align_size_up(MaxHeapSize, _max_alignment);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // Check heap parameter properties
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    72
  if (_initial_heap_byte_size < M) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    vm_exit_during_initialization("Too small initial heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // Check heap parameter properties
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    76
  if (_min_heap_byte_size < M) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    vm_exit_during_initialization("Too small minimum heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    79
  if (_initial_heap_byte_size <= NewSize) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
     // make sure there is at least some room in old space
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    vm_exit_during_initialization("Too small initial heap for new size specified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    83
  if (_max_heap_byte_size < _min_heap_byte_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    86
  if (_initial_heap_byte_size < _min_heap_byte_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    89
  if (_max_heap_byte_size < _initial_heap_byte_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
    92
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
    93
  if (PrintGCDetails && Verbose) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
    94
    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
    95
      SIZE_FORMAT "  Maximum heap " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
    96
      _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
    97
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   100
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
   101
  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
   102
  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
   103
  return result;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   104
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
                                           int max_covered_regions) {
20316
d3ef45219aac 8025855: Simplify GenRemSet code slightly
jwilhelm
parents: 20312
diff changeset
   108
  assert(rem_set_name() == GenRemSet::CardTable, "unrecognized GenRemSet::Name");
d3ef45219aac 8025855: Simplify GenRemSet code slightly
jwilhelm
parents: 20312
diff changeset
   109
  return new CardTableRS(whole_heap, max_covered_regions);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   112
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
   113
  // 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
   114
  // 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
   115
  // 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
   116
  if (size_policy() != NULL) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   117
    _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
   118
  }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   119
  _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
   120
}
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   121
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   122
size_t CollectorPolicy::compute_max_alignment() {
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   123
  // 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
   124
  // 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
   125
  // 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
   126
  // 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
   127
  // be 512*4096 = 2MB aligned.
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   128
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   129
  // There is only the GenRemSet in Hotspot and only the GenRemSet::CardTable
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   130
  // is supported.
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   131
  // Requirements of any new remembered set implementations must be added here.
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   132
  size_t alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable);
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   133
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   134
  // Parallel GC does its own alignment of the generations to avoid requiring a
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   135
  // large page (256M on some platforms) for the permanent generation.  The
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   136
  // other collectors should also be updated to do their own alignment and then
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   137
  // this use of lcm() should be removed.
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   138
  if (UseLargePages && !UseParallelGC) {
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   139
      // in presence of large pages we have to make sure that our
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   140
      // alignment is large page aware
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   141
      alignment = lcm(os::large_page_size(), alignment);
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   142
  }
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   143
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   144
  return alignment;
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19546
diff changeset
   145
}
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   146
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
// GenCollectorPolicy methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   149
size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   150
  size_t x = base_size / (NewRatio+1);
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   151
  size_t new_gen_size = x > _min_alignment ?
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   152
                     align_size_down(x, _min_alignment) :
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   153
                     _min_alignment;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   154
  return new_gen_size;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   155
}
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   156
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   157
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
   158
                                                 size_t maximum_size) {
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   159
  size_t alignment = _min_alignment;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   160
  size_t max_minus = maximum_size - alignment;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   161
  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
   162
}
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   163
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   164
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
                                                size_t init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
                                                size_t 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
   168
  const double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  _size_policy = new AdaptiveSizePolicy(init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
                                        init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
                                        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
   172
                                        max_gc_pause_sec,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
                                        GCTimeRatio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
void GenCollectorPolicy::initialize_flags() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // All sizes must be multiples of the generation granularity.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   178
  _min_alignment = (uintx) Generation::GenGrain;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   179
  _max_alignment = compute_max_alignment();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  CollectorPolicy::initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // All generational heaps have a youngest gen; handle those flags here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // Adjust max size parameters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  if (NewSize > MaxNewSize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    MaxNewSize = NewSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   189
  NewSize = align_size_down(NewSize, _min_alignment);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   190
  MaxNewSize = align_size_down(MaxNewSize, _min_alignment);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // Check validity of heap flags
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   193
  assert(NewSize     % _min_alignment == 0, "eden space alignment");
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   194
  assert(MaxNewSize  % _min_alignment == 0, "survivor space alignment");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   196
  if (NewSize < 3 * _min_alignment) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
     // make sure there room for eden and two survivor spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    vm_exit_during_initialization("Too small new size specified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  if (SurvivorRatio < 1 || NewRatio < 1) {
20399
d9bb551bf53d 8025854: Use "young gen" instead of "eden"
jwilhelm
parents: 20398
diff changeset
   201
    vm_exit_during_initialization("Invalid young gen ratio specified");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
void TwoGenerationCollectorPolicy::initialize_flags() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  GenCollectorPolicy::initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   208
  OldSize = align_size_down(OldSize, _min_alignment);
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   209
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   210
  if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) {
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   211
    // 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
   212
    // 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
   213
    // and NewRatio.
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   214
    assert(NewRatio > 0, "NewRatio should have been set up earlier");
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   215
    size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   216
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   217
    calculated_heapsize = align_size_up(calculated_heapsize, _max_alignment);
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   218
    MaxHeapSize = calculated_heapsize;
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   219
    InitialHeapSize = calculated_heapsize;
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   220
  }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   221
  MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   223
  // adjust max heap size if necessary
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   224
  if (NewSize + OldSize > MaxHeapSize) {
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   225
    if (FLAG_IS_CMDLINE(MaxHeapSize)) {
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   226
      // somebody set a maximum heap size with the intention that we should not
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   227
      // exceed it. Adjust New/OldSize as necessary.
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   228
      uintx calculated_size = NewSize + OldSize;
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   229
      double shrink_factor = (double) MaxHeapSize / calculated_size;
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   230
      // align
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   231
      NewSize = align_size_down((uintx) (NewSize * shrink_factor), _min_alignment);
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   232
      // OldSize is already aligned because above we aligned MaxHeapSize to
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   233
      // _max_alignment, and we just made sure that NewSize is aligned to
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   234
      // _min_alignment. In initialize_flags() we verified that _max_alignment
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   235
      // is a multiple of _min_alignment.
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   236
      OldSize = MaxHeapSize - NewSize;
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   237
    } else {
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   238
      MaxHeapSize = NewSize + OldSize;
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   239
    }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   240
  }
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   241
  // need to do this again
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   242
  MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
17322
35c488005999 8006088: Incompatible heap size flags accepted by VM
tschatzl
parents: 17320
diff changeset
   243
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   244
  // adjust max heap size if necessary
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   245
  if (NewSize + OldSize > MaxHeapSize) {
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   246
    if (FLAG_IS_CMDLINE(MaxHeapSize)) {
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   247
      // somebody set a maximum heap size with the intention that we should not
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   248
      // exceed it. Adjust New/OldSize as necessary.
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   249
      uintx calculated_size = NewSize + OldSize;
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   250
      double shrink_factor = (double) MaxHeapSize / calculated_size;
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   251
      // align
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   252
      NewSize = align_size_down((uintx) (NewSize * shrink_factor), _min_alignment);
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   253
      // OldSize is already aligned because above we aligned MaxHeapSize to
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   254
      // _max_alignment, and we just made sure that NewSize is aligned to
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   255
      // _min_alignment. In initialize_flags() we verified that _max_alignment
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   256
      // is a multiple of _min_alignment.
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   257
      OldSize = MaxHeapSize - NewSize;
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   258
    } else {
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   259
      MaxHeapSize = NewSize + OldSize;
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   260
    }
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   261
  }
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   262
  // need to do this again
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   263
  MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
17389
25ba661e4352 8014058: Regression tests for 8006088
tschatzl
parents: 17322
diff changeset
   264
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  always_do_update_barrier = UseConcMarkSweepGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // Check validity of heap flags
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   268
  assert(OldSize     % _min_alignment == 0, "old space alignment");
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   269
  assert(MaxHeapSize % _max_alignment == 0, "maximum heap alignment");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   272
// 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
   273
// set command line parameters.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   274
// 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
   275
// 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
   276
// 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
   277
// 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
   278
// themselves and with overall heap sizings.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   279
// 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
   280
// such as the use of NewRatio are used to size the generation.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
void GenCollectorPolicy::initialize_size_info() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  CollectorPolicy::initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   284
  // _min_alignment is used for alignment within a generation.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   285
  // There is additional alignment done down stream for some
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   286
  // collectors that sometimes causes unwanted rounding up of
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   287
  // generations sizes.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   288
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   289
  // Determine maximum size of gen0
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   290
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   291
  size_t max_new_size = 0;
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   292
  if (FLAG_IS_CMDLINE(MaxNewSize) || FLAG_IS_ERGO(MaxNewSize)) {
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   293
    if (MaxNewSize < _min_alignment) {
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   294
      max_new_size = _min_alignment;
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   295
    }
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   296
    if (MaxNewSize >= _max_heap_byte_size) {
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   297
      max_new_size = align_size_down(_max_heap_byte_size - _min_alignment,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   298
                                     _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   299
      warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or "
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   300
        "greater than the entire heap (" SIZE_FORMAT "k).  A "
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   301
        "new generation size of " SIZE_FORMAT "k will be used.",
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   302
        MaxNewSize/K, _max_heap_byte_size/K, max_new_size/K);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   303
    } else {
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   304
      max_new_size = align_size_down(MaxNewSize, _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   305
    }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   306
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   307
  // The case for FLAG_IS_ERGO(MaxNewSize) could be treated
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   308
  // specially at this point to just use an ergonomically set
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   309
  // MaxNewSize to set max_new_size.  For cases with small
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   310
  // heaps such a policy often did not work because the MaxNewSize
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   311
  // was larger than the entire heap.  The interpretation given
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   312
  // to ergonomically set flags is that the flags are set
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   313
  // by different collectors for their own special needs but
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   314
  // are not allowed to badly shape the heap.  This allows the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   315
  // different collectors to decide what's best for themselves
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   316
  // without having to factor in the overall heap shape.  It
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   317
  // can be the case in the future that the collectors would
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   318
  // only make "wise" ergonomics choices and this policy could
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   319
  // just accept those choices.  The choices currently made are
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   320
  // not always "wise".
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  } else {
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   322
    max_new_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
   323
    // Bound the maximum size by NewSize below (since it historically
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    // would have been NewSize and because the NewRatio calculation could
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    // 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
   326
    // 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
   327
    // NewSize and MaxNewSize.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   328
    max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   329
  }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   330
  assert(max_new_size > 0, "All paths should set max_new_size");
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   331
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   332
  // Given the maximum gen0 size, determine the initial and
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   333
  // minimum gen0 sizes.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   334
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   335
  if (_max_heap_byte_size == _min_heap_byte_size) {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   336
    // The maximum and minimum heap sizes are the same so
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   337
    // the generations minimum and initial must be the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   338
    // same as its maximum.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   339
    _min_gen0_size = max_new_size;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   340
    _initial_gen0_size = max_new_size;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   341
    _max_gen0_size = max_new_size;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   342
  } else {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   343
    size_t desired_new_size = 0;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   344
    if (!FLAG_IS_DEFAULT(NewSize)) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   345
      // If NewSize is set ergonomically (for example by cms), it
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   346
      // would make sense to use it.  If it is used, also use it
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   347
      // to set the initial size.  Although there is no reason
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   348
      // the minimum size and the initial size have to be the same,
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   349
      // the current implementation gets into trouble during the calculation
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   350
      // of the tenured generation sizes if they are different.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   351
      // Note that this makes the initial size and the minimum size
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   352
      // generally small compared to the NewRatio calculation.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   353
      _min_gen0_size = NewSize;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   354
      desired_new_size = NewSize;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   355
      max_new_size = MAX2(max_new_size, NewSize);
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   356
    } else {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   357
      // For the case where NewSize is the default, use NewRatio
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   358
      // to size the minimum and initial generation sizes.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   359
      // Use the default NewSize as the floor for these values.  If
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   360
      // NewRatio is overly large, the resulting sizes can be too
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   361
      // small.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   362
      _min_gen0_size = MAX2(scale_by_NewRatio_aligned(_min_heap_byte_size), NewSize);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   363
      desired_new_size =
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   364
        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
   365
    }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   366
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   367
    assert(_min_gen0_size > 0, "Sanity check");
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   368
    _initial_gen0_size = desired_new_size;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   369
    _max_gen0_size = max_new_size;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   370
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   371
    // At this point the desirable initial and minimum sizes have been
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   372
    // determined without regard to the maximum sizes.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   373
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   374
    // Bound the sizes by the corresponding overall heap sizes.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   375
    _min_gen0_size = bound_minus_alignment(_min_gen0_size, _min_heap_byte_size);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   376
    _initial_gen0_size = bound_minus_alignment(_initial_gen0_size, _initial_heap_byte_size);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   377
    _max_gen0_size = bound_minus_alignment(_max_gen0_size, _max_heap_byte_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   378
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   379
    // At this point all three sizes have been checked against the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   380
    // maximum sizes but have not been checked for consistency
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 186
diff changeset
   381
    // among the three.
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   382
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   383
    // Final check min <= initial <= max
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   384
    _min_gen0_size = MIN2(_min_gen0_size, _max_gen0_size);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   385
    _initial_gen0_size = MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   386
    _min_gen0_size = MIN2(_min_gen0_size, _initial_gen0_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   389
  if (PrintGCDetails && Verbose) {
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   390
    gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   391
      SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   392
      _min_gen0_size, _initial_gen0_size, _max_gen0_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   393
  }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   394
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   396
// Call this method during the sizing of the gen1 to make
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   397
// adjustments to gen0 because of gen1 sizing policy.  gen0 initially has
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   398
// the most freedom in sizing because it is done before the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   399
// policy for gen1 is applied.  Once gen1 policies have been applied,
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   400
// there may be conflicts in the shape of the heap and this method
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   401
// is used to make the needed adjustments.  The application of the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   402
// policies could be more sophisticated (iterative for example) but
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   403
// keeping it simple also seems a worthwhile goal.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   404
bool TwoGenerationCollectorPolicy::adjust_gen0_sizes(size_t* gen0_size_ptr,
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   405
                                                     size_t* gen1_size_ptr,
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   406
                                                     const size_t heap_size,
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   407
                                                     const size_t min_gen1_size) {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   408
  bool result = false;
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   409
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   410
  if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) {
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   411
    if ((heap_size < (*gen0_size_ptr + min_gen1_size)) &&
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   412
        (heap_size >= min_gen1_size + _min_alignment)) {
15494
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   413
      // Adjust gen0 down to accommodate min_gen1_size
b3a322a0bea5 6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents: 15091
diff changeset
   414
      *gen0_size_ptr = heap_size - min_gen1_size;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   415
      *gen0_size_ptr =
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   416
        MAX2((uintx)align_size_down(*gen0_size_ptr, _min_alignment), _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   417
      assert(*gen0_size_ptr > 0, "Min gen0 is too large");
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   418
      result = true;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   419
    } else {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   420
      *gen1_size_ptr = heap_size - *gen0_size_ptr;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   421
      *gen1_size_ptr =
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   422
        MAX2((uintx)align_size_down(*gen1_size_ptr, _min_alignment), _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   423
    }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   424
  }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   425
  return result;
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   426
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   428
// Minimum sizes of the generations may be different than
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   429
// the initial sizes.  An inconsistently is permitted here
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   430
// in the total size that can be specified explicitly by
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   431
// command line specification of OldSize and NewSize and
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   432
// also a command line specification of -Xms.  Issue a warning
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   433
// but allow the values to pass.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
void TwoGenerationCollectorPolicy::initialize_size_info() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  GenCollectorPolicy::initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   438
  // At this point the minimum, initial and maximum sizes
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   439
  // of the overall heap and of gen0 have been determined.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   440
  // The maximum gen1 size can be determined from the maximum gen0
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   441
  // and maximum heap size since no explicit flags exits
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   442
  // for setting the gen1 maximum.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   443
  _max_gen1_size = _max_heap_byte_size - _max_gen0_size;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   444
  _max_gen1_size =
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   445
    MAX2((uintx)align_size_down(_max_gen1_size, _min_alignment), _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   446
  // If no explicit command line flag has been set for the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   447
  // gen1 size, use what is left for gen1.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   448
  if (FLAG_IS_DEFAULT(OldSize) || FLAG_IS_ERGO(OldSize)) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   449
    // The user has not specified any value or ergonomics
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   450
    // has chosen a value (which may or may not be consistent
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   451
    // 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
   452
    // the minimum, maximum and initial sizes consistent
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   453
    // with the gen0 sizes and the overall heap sizes.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   454
    assert(_min_heap_byte_size > _min_gen0_size,
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   455
      "gen0 has an unexpected minimum size");
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   456
    _min_gen1_size = _min_heap_byte_size - _min_gen0_size;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   457
    _min_gen1_size =
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   458
      MAX2((uintx)align_size_down(_min_gen1_size, _min_alignment), _min_alignment);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   459
    _initial_gen1_size = _initial_heap_byte_size - _initial_gen0_size;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   460
    _initial_gen1_size =
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   461
      MAX2((uintx)align_size_down(_initial_gen1_size, _min_alignment), _min_alignment);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   462
  } else {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   463
    // It's been explicitly set on the command line.  Use the
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   464
    // OldSize and then determine the consequences.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   465
    _min_gen1_size = OldSize;
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   466
    _initial_gen1_size = OldSize;
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   467
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   468
    // 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
   469
    // with other command line flags, issue a warning.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    // The generation minimums and the overall heap mimimum should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    // be within one heap alignment.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   472
    if ((_min_gen1_size + _min_gen0_size + _min_alignment) < _min_heap_byte_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
      warning("Inconsistency between minimum heap size and minimum "
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   474
              "generation sizes: using minimum heap = " SIZE_FORMAT,
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   475
              _min_heap_byte_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   476
    }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   477
    if ((OldSize > _max_gen1_size)) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   478
      warning("Inconsistency between maximum heap size and maximum "
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   479
              "generation sizes: using maximum heap = " SIZE_FORMAT
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   480
              " -XX:OldSize flag is being ignored",
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   481
              _max_heap_byte_size);
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   482
    }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   483
    // If there is an inconsistency between the OldSize and the minimum and/or
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   484
    // initial size of gen0, since OldSize was explicitly set, OldSize wins.
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   485
    if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   486
                          _min_heap_byte_size, OldSize)) {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   487
      if (PrintGCDetails && Verbose) {
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   488
        gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   489
              SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   490
              _min_gen0_size, _initial_gen0_size, _max_gen0_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   491
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   493
    // Initial size
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   494
    if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   495
                          _initial_heap_byte_size, OldSize)) {
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   496
      if (PrintGCDetails && Verbose) {
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7419
diff changeset
   497
        gclog_or_tty->print_cr("3: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   498
          SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   499
          _min_gen0_size, _initial_gen0_size, _max_gen0_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   500
      }
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   501
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   503
  // Enforce the maximum gen1 size.
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   504
  _min_gen1_size = MIN2(_min_gen1_size, _max_gen1_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   506
  // Check that min gen1 <= initial gen1 <= max gen1
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   507
  _initial_gen1_size = MAX2(_initial_gen1_size, _min_gen1_size);
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   508
  _initial_gen1_size = MIN2(_initial_gen1_size, _max_gen1_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   509
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   510
  if (PrintGCDetails && Verbose) {
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   511
    gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT "  Initial gen1 "
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   512
      SIZE_FORMAT "  Maximum gen1 " SIZE_FORMAT,
20398
b206c580c45f 8025852: Remove unnecessary setters in collector policy classes
jwilhelm
parents: 20316
diff changeset
   513
      _min_gen1_size, _initial_gen1_size, _max_gen1_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   514
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
                                        bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
                                        bool* gc_overhead_limit_was_exceeded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  debug_only(gch->check_for_valid_allocation_state());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  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
   524
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   525
  // 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
   526
  // 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
   527
  // 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
   528
  *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
   529
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  // Loop until the allocation is satisified,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // or unsatisfied after GC.
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   534
  for (int try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    HandleMark hm; // discard any handles allocated in each iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    // First allocation attempt is lock-free.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    Generation *gen0 = gch->get_gen(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    assert(gen0->supports_inline_contig_alloc(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
      "Otherwise, must do alloc within heap lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    if (gen0->should_allocate(size, is_tlab)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      result = gen0->par_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    unsigned int gc_count_before;  // read inside the Heap_lock locked region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
      MutexLocker ml(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
      if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
        gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
                      " attempting locked slow path allocation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
      // Note that only large objects get a shot at being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
      // allocated in later generations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
      bool first_only = ! should_try_older_generation_allocation(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
      result = gch->attempt_allocation(size, is_tlab, first_only);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
      if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
        assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
        return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
      if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
        if (is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
          return NULL;  // Caller will retry allocating individual object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
        if (!gch->is_maximal_no_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
          // Try and expand heap to satisfy request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
          result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
          // result could be null if we are out of space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
          if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
            return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   578
        if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   579
          return NULL; // we didn't get to do a GC and we didn't get any memory
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   580
        }
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   581
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
        // If this thread is not in a jni critical section, we stall
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
        // the requestor until the critical section has cleared and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
        // GC allowed. When the critical section clears, a GC is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
        // initiated by the last thread exiting the critical section; so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
        // we retry the allocation sequence from the beginning of the loop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
        // rather than causing more, now probably unnecessary, GC attempts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
        JavaThread* jthr = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
        if (!jthr->in_critical()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
          MutexUnlocker mul(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
          // Wait for JNI critical section to be exited
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
          GC_locker::stall_until_clear();
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15959
diff changeset
   593
          gclocker_stalled_count += 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
          if (CheckJNICalls) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
            fatal("Possible deadlock due to allocating while"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
                  " in jni critical section");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
          return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
      // Read the gc count while the heap lock is held.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
      gc_count_before = Universe::heap()->total_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    VM_GenCollectForAllocation op(size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
                                  is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
                                  gc_count_before);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
    VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    if (op.prologue_succeeded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      result = op.result();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
      if (op.gc_locked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
         assert(result == NULL, "must be NULL if gc_locked() is true");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
         continue;  // retry and/or stall as necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
      }
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   618
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   619
      // 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
   620
      // 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
   621
      // 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
   622
      // 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
   623
      // 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
   624
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   625
      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
   626
      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
   627
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   628
      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
   629
        *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
   630
        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
   631
        if (op.result() != NULL) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   632
          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
   633
        }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   634
        return NULL;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   635
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
      assert(result == NULL || gch->is_in_reserved(result),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
             "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    // Give a warning if we seem to be looping forever.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    if ((QueuedAllocationWarningCount > 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
        (try_count % QueuedAllocationWarningCount == 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
          warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
                  " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
                                                       bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    Generation *gen = gch->get_gen(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    if (gen->should_allocate(size, is_tlab)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      result = gen->expand_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  assert(result == NULL || gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
                                                        bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  GenCollectedHeap *gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  GCCauseSetter x(gch, GCCause::_allocation_failure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  assert(size != 0, "Precondition violated");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  if (GC_locker::is_active_and_needs_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    // GC locker is active; instead of a collection we will attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    // to expand the heap, if there's room for expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    if (!gch->is_maximal_no_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    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
   678
  } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    // Do an incremental collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    gch->do_collection(false            /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
                       false            /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  } else {
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   686
    if (Verbose && PrintGCDetails) {
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   687
      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
   688
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    // Try a full collection; see delta for bug id 6266275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
    // for the original code and why this has been simplified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    // with from-space allocation criteria modified and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    // such allocation moved out of the safepoint path.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
    gch->do_collection(true             /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
                       false            /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // OK, collection failed, try expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  result = expand_heap_and_allocate(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  // If we reach this point, we're really out of memory. Try every trick
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  // we can to reclaim memory. Force collection of soft references. Force
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  // a complete compaction of the heap. Any additional methods for finding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  // free memory should be here, especially if they are expensive. If this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  // attempt fails, an OOM exception will be thrown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  {
17392
2f967c0e4246 6843347: Boundary values in some public GC options cause crashes
tschatzl
parents: 17389
diff changeset
   719
    UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    gch->do_collection(true             /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
                       true             /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
                       size             /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
                       is_tlab          /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
                       number_of_generations() - 1 /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    assert(gch->is_in_reserved(result), "result not in heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4434
diff changeset
   734
  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
   735
    "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
   736
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  // What else?  We might try synchronous finalization later.  If the total
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  // space available is large enough for the allocation, then a more
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  // complete compaction phase than we've tried so far might be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  // appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   744
MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   745
                                                 ClassLoaderData* loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   746
                                                 size_t word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   747
                                                 Metaspace::MetadataType mdtype) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   748
  uint loop_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   749
  uint gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   750
  uint full_gc_count = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   751
14291
c8e69e83977f 8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents: 13755
diff changeset
   752
  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
   753
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   754
  do {
13755
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   755
    MetaWord* result = NULL;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   756
    if (GC_locker::is_active_and_needs_gc()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   757
      // 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
   758
      // 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
   759
      // in a critical section itself.
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   760
      result =
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   761
        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
   762
                                                               mdtype);
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   763
      if (result != NULL) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   764
        return result;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   765
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   766
      JavaThread* jthr = JavaThread::current();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   767
      if (!jthr->in_critical()) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   768
        // Wait for JNI critical section to be exited
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   769
        GC_locker::stall_until_clear();
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   770
        // 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
   771
        // 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
   772
        // is (currently) needed for unloading classes so continue
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   773
        // 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
   774
        continue;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   775
      } else {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   776
        if (CheckJNICalls) {
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   777
          fatal("Possible deadlock due to allocating while"
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   778
                " in jni critical section");
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   779
        }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   780
        return NULL;
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   781
      }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   782
    }
a00f5de57d30 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents: 13728
diff changeset
   783
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   784
    {  // 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
   785
      MutexLocker ml(Heap_lock);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   786
      gc_count      = Universe::heap()->total_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   787
      full_gc_count = Universe::heap()->total_full_collections();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   788
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   789
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   790
    // Generate a VM operation
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   791
    VM_CollectForMetadataAllocation op(loader_data,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   792
                                       word_size,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   793
                                       mdtype,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   794
                                       gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   795
                                       full_gc_count,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   796
                                       GCCause::_metadata_GC_threshold);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   797
    VMThread::execute(&op);
15086
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   798
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   799
    // If GC was locked out, try again.  Check
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   800
    // before checking success because the prologue
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   801
    // could have succeeded and the GC still have
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   802
    // been locked out.
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   803
    if (op.gc_locked()) {
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   804
      continue;
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   805
    }
2bfd799e9147 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents: 14583
diff changeset
   806
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   807
    if (op.prologue_succeeded()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   808
      return op.result();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   809
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   810
    loop_count++;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   811
    if ((QueuedAllocationWarningCount > 0) &&
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   812
        (loop_count % QueuedAllocationWarningCount == 0)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   813
      warning("satisfy_failed_metadata_allocation() retries %d times \n\t"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   814
              " size=%d", loop_count, word_size);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   815
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   816
  } while (true);  // Until a GC is done
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   817
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10565
diff changeset
   818
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
// Return true if any of the following is true:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
// . the allocation won't fit into the current young gen heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
// . gc locker is occupied (jni critical section)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
// . heap memory is tight -- the most recent previous collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
//   was a full collection because a partial collection (would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
//   have) failed and is likely to fail again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
bool GenCollectorPolicy::should_try_older_generation_allocation(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
        size_t word_size) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  GenCollectedHeap* gch = GenCollectedHeap::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  return    (word_size > heap_word_size(gen0_capacity))
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 6465
diff changeset
   830
         || 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
   831
         || gch->incremental_collection_failed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
// MarkSweepPolicy methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
MarkSweepPolicy::MarkSweepPolicy() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  initialize_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
void MarkSweepPolicy::initialize_generations() {
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 17322
diff changeset
   844
  _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, 0, AllocFailStrategy::RETURN_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  if (_generations == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    vm_exit_during_initialization("Unable to allocate gen spec");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
15091
826cff1f58f5 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents: 15086
diff changeset
   848
  if (UseParNewGC) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
    _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
    _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  if (_generations[0] == NULL || _generations[1] == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
    vm_exit_during_initialization("Unable to allocate gen spec");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
void MarkSweepPolicy::initialize_gc_policy_counters() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  // initialize the policy counters - 2 collectors, 3 generations
15091
826cff1f58f5 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents: 15086
diff changeset
   861
  if (UseParNewGC) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
    _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3);
15091
826cff1f58f5 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents: 15086
diff changeset
   863
  } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
    _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
}