hotspot/src/share/vm/memory/tenuredGeneration.cpp
author zgu
Thu, 28 Jun 2012 17:03:16 -0400
changeset 13195 be27e1b6a4b9
parent 7397 5b173b4ca846
child 13466 9fdf353d5f4c
permissions -rw-r--r--
6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
     2
 * Copyright (c) 2001, 2010, 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: 2105
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2105
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: 2105
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/parNew/parGCAllocBuffer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    27
#include "gc_implementation/shared/collectorCounters.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    28
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    29
#include "memory/blockOffsetTable.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    30
#include "memory/generation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    31
#include "memory/generationSpec.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    32
#include "memory/space.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    33
#include "memory/tenuredGeneration.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    34
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    35
#include "runtime/java.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
TenuredGeneration::TenuredGeneration(ReservedSpace rs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
                                     size_t initial_byte_size, int level,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
                                     GenRemSet* remset) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  OneContigSpaceCardGeneration(rs, initial_byte_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
                               MinHeapDeltaBytes, level, remset, NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  HeapWord* bottom = (HeapWord*) _virtual_space.low();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  HeapWord* end    = (HeapWord*) _virtual_space.high();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  _the_space  = new TenuredSpace(_bts, MemRegion(bottom, end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  _the_space->reset_saved_mark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  _shrink_factor = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  _capacity_at_prologue = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  _gc_stats = new GCStats();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  // initialize performance counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  const char* gen_name = "old";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  // Generation Counters -- generation 1, 1 subspace
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  _gen_counters = new GenerationCounters(gen_name, 1, 1, &_virtual_space);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  _gc_counters = new CollectorCounters("MSC", 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  _space_counters = new CSpaceCounters(gen_name, 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
                                       _virtual_space.reserved_size(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
                                       _the_space, _gen_counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  if (UseParNewGC && ParallelGCThreads > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    typedef ParGCAllocBufferWithBOT* ParGCAllocBufferWithBOTPtr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    _alloc_buffers = NEW_C_HEAP_ARRAY(ParGCAllocBufferWithBOTPtr,
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
    68
                                      ParallelGCThreads, mtGC);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    if (_alloc_buffers == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
      vm_exit_during_initialization("Could not allocate alloc_buffers");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    for (uint i = 0; i < ParallelGCThreads; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
      _alloc_buffers[i] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
        new ParGCAllocBufferWithBOT(OldPLABSize, _bts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
      if (_alloc_buffers[i] == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
        vm_exit_during_initialization("Could not allocate alloc_buffers");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    _alloc_buffers = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
const char* TenuredGeneration::name() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  return "tenured generation";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
void TenuredGeneration::compute_new_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  assert(_shrink_factor <= 100, "invalid shrink factor");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  size_t current_shrink_factor = _shrink_factor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  _shrink_factor = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // We don't have floating point command-line arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // Note:  argument processing ensures that MinHeapFreeRatio < 100.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  const double minimum_free_percentage = MinHeapFreeRatio / 100.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  const double maximum_used_percentage = 1.0 - minimum_free_percentage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // Compute some numbers about the state of the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  const size_t used_after_gc = used();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  const size_t capacity_after_gc = capacity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  const double min_tmp = used_after_gc / maximum_used_percentage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  size_t minimum_desired_capacity = (size_t)MIN2(min_tmp, double(max_uintx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // Don't shrink less than the initial generation size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  minimum_desired_capacity = MAX2(minimum_desired_capacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
                                  spec()->init_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  assert(used_after_gc <= minimum_desired_capacity, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    const size_t free_after_gc = free();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    const double free_percentage = ((double)free_after_gc) / capacity_after_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    gclog_or_tty->print_cr("TenuredGeneration::compute_new_size: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
                  "  minimum_free_percentage: %6.2f"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                  "  maximum_used_percentage: %6.2f",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                  minimum_free_percentage,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                  maximum_used_percentage);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
                  "   free_after_gc   : %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
                  "   used_after_gc   : %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
                  "   capacity_after_gc   : %6.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
                  free_after_gc / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
                  used_after_gc / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
                  capacity_after_gc / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
                  "   free_percentage: %6.2f",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
                  free_percentage);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  if (capacity_after_gc < minimum_desired_capacity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    // If we have less free space than we want then expand
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    size_t expand_bytes = minimum_desired_capacity - capacity_after_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    // Don't expand unless it's significant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    if (expand_bytes >= _min_heap_delta_bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      expand(expand_bytes, 0); // safe if expansion fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
      gclog_or_tty->print_cr("    expanding:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
                    "  minimum_desired_capacity: %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
                    "  expand_bytes: %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
                    "  _min_heap_delta_bytes: %6.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
                    minimum_desired_capacity / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
                    expand_bytes / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
                    _min_heap_delta_bytes / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // No expansion, now see if we want to shrink
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  size_t shrink_bytes = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // We would never want to shrink more than this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  size_t max_shrink_bytes = capacity_after_gc - minimum_desired_capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (MaxHeapFreeRatio < 100) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    const double maximum_free_percentage = MaxHeapFreeRatio / 100.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    const double minimum_used_percentage = 1.0 - maximum_free_percentage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    const double max_tmp = used_after_gc / minimum_used_percentage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
    maximum_desired_capacity = MAX2(maximum_desired_capacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
                                    spec()->init_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
      gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
                             "  maximum_free_percentage: %6.2f"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
                             "  minimum_used_percentage: %6.2f",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
                             maximum_free_percentage,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
                             minimum_used_percentage);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
      gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
                             "  _capacity_at_prologue: %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
                             "  minimum_desired_capacity: %6.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
                             "  maximum_desired_capacity: %6.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
                             _capacity_at_prologue / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
                             minimum_desired_capacity / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
                             maximum_desired_capacity / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
    assert(minimum_desired_capacity <= maximum_desired_capacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
           "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    if (capacity_after_gc > maximum_desired_capacity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
      // Capacity too large, compute shrinking size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
      shrink_bytes = capacity_after_gc - maximum_desired_capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      // We don't want shrink all the way back to initSize if people call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      // System.gc(), because some programs do that between "phases" and then
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      // we'd just have to grow the heap up again for the next phase.  So we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      // damp the shrinking: 0% on the first call, 10% on the second call, 40%
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      // on the third call, and 100% by the fourth call.  But if we recompute
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
      // size without shrinking, it goes back to 0%.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
      shrink_bytes = shrink_bytes / 100 * current_shrink_factor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
      assert(shrink_bytes <= max_shrink_bytes, "invalid shrink size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
      if (current_shrink_factor == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
        _shrink_factor = 10;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
        _shrink_factor = MIN2(current_shrink_factor * 4, (size_t) 100);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
      if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
        gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
                      "  shrinking:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
                      "  initSize: %.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
                      "  maximum_desired_capacity: %.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
                      spec()->init_size() / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
                      maximum_desired_capacity / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
        gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
                      "  shrink_bytes: %.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
                      "  current_shrink_factor: %d"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
                      "  new shrink factor: %d"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
                      "  _min_heap_delta_bytes: %.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
                      shrink_bytes / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
                      current_shrink_factor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
                      _shrink_factor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
                      _min_heap_delta_bytes / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  if (capacity_after_gc > _capacity_at_prologue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    // We might have expanded for promotions, in which case we might want to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    // take back that expansion if there's room after GC.  That keeps us from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    // stretching the heap with promotions when there's plenty of room.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    size_t expansion_for_promotion = capacity_after_gc - _capacity_at_prologue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    expansion_for_promotion = MIN2(expansion_for_promotion, max_shrink_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    // We have two shrinking computations, take the largest
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    shrink_bytes = MAX2(shrink_bytes, expansion_for_promotion);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    assert(shrink_bytes <= max_shrink_bytes, "invalid shrink size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
      gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
                             "  aggressive shrinking:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
                             "  _capacity_at_prologue: %.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
                             "  capacity_after_gc: %.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
                             "  expansion_for_promotion: %.1fK"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
                             "  shrink_bytes: %.1fK",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                             capacity_after_gc / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
                             _capacity_at_prologue / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
                             expansion_for_promotion / (double) K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
                             shrink_bytes / (double) K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // Don't shrink unless it's significant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  if (shrink_bytes >= _min_heap_delta_bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    shrink(shrink_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  assert(used() == used_after_gc && used_after_gc <= capacity(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
         "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
void TenuredGeneration::gc_prologue(bool full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  _capacity_at_prologue = capacity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  _used_at_prologue = used();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  if (VerifyBeforeGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    verify_alloc_buffers_clean();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
void TenuredGeneration::gc_epilogue(bool full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  if (VerifyAfterGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    verify_alloc_buffers_clean();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  OneContigSpaceCardGeneration::gc_epilogue(full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
bool TenuredGeneration::should_collect(bool  full,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
                                       size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
                                       bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // This should be one big conditional or (||), but I want to be able to tell
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // why it returns what it returns (without re-evaluating the conditionals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // in case they aren't idempotent), so I'm doing it this way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // DeMorgan says it's okay.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  bool result = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  if (!result && full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
      gclog_or_tty->print_cr("TenuredGeneration::should_collect: because"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
                    " full");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  if (!result && should_allocate(size, is_tlab)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
      gclog_or_tty->print_cr("TenuredGeneration::should_collect: because"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
                    " should_allocate(" SIZE_FORMAT ")",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
                    size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  // If we don't have very much free space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // XXX: 10000 should be a percentage of the capacity!!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  if (!result && free() < 10000) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      gclog_or_tty->print_cr("TenuredGeneration::should_collect: because"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
                    " free(): " SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
                    free());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // If we had to expand to accomodate promotions from younger generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  if (!result && _capacity_at_prologue < capacity()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    if (PrintGC && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      gclog_or_tty->print_cr("TenuredGeneration::should_collect: because"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
                    "_capacity_at_prologue: " SIZE_FORMAT " < capacity(): " SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
                    _capacity_at_prologue, capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
void TenuredGeneration::collect(bool   full,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
                                bool   clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
                                size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
                                bool   is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  retire_alloc_buffers_before_full_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  OneContigSpaceCardGeneration::collect(full, clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
                                        size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
void TenuredGeneration::update_gc_stats(int current_level,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
                                        bool full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // If the next lower level(s) has been collected, gather any statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  // that are of interest at this point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  if (!full && (current_level + 1) == level()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    // Calculate size of data promoted from the younger generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    // before doing the collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    size_t used_before_gc = used();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    // If the younger gen collections were skipped, then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    // number of promoted bytes will be 0 and adding it to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    // average will incorrectly lessen the average.  It is, however,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
    // also possible that no promotion was needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    if (used_before_gc >= _used_at_prologue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      size_t promoted_in_bytes = used_before_gc - _used_at_prologue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
      gc_stats()->avg_promoted()->sample(promoted_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
void TenuredGeneration::update_counters() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    _space_counters->update_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    _gen_counters->update_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
oop TenuredGeneration::par_promote(int thread_num,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
                                   oop old, markOop m, size_t word_sz) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  ParGCAllocBufferWithBOT* buf = _alloc_buffers[thread_num];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  HeapWord* obj_ptr = buf->allocate(word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  bool is_lab = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  if (obj_ptr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    if (Universe::heap()->promotion_should_fail()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
      return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    // Slow path:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    if (word_sz * 100 < ParallelGCBufferWastePct * buf->word_sz()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
      // Is small enough; abandon this buffer and start a new one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
      size_t buf_size = buf->word_sz();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
      HeapWord* buf_space =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
        TenuredGeneration::par_allocate(buf_size, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
      if (buf_space == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
        buf_space = expand_and_allocate(buf_size, false, true /* parallel*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
      if (buf_space != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
        buf->retire(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
        buf->set_buf(buf_space);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
        obj_ptr = buf->allocate(word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
        assert(obj_ptr != NULL, "Buffer was definitely big enough...");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    // Otherwise, buffer allocation failed; try allocating object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    // individually.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    if (obj_ptr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
      obj_ptr = TenuredGeneration::par_allocate(word_sz, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      if (obj_ptr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
        obj_ptr = expand_and_allocate(word_sz, false, true /* parallel */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    if (obj_ptr == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  assert(obj_ptr != NULL, "program logic");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  Copy::aligned_disjoint_words((HeapWord*)old, obj_ptr, word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  oop obj = oop(obj_ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // Restore the mark word copied above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  obj->set_mark(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
void TenuredGeneration::par_promote_alloc_undo(int thread_num,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
                                               HeapWord* obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
                                               size_t word_sz) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  ParGCAllocBufferWithBOT* buf = _alloc_buffers[thread_num];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  if (buf->contains(obj)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    guarantee(buf->contains(obj + word_sz - 1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
              "should contain whole object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    buf->undo_allocation(obj, word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  } else {
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 670
diff changeset
   399
    CollectedHeap::fill_with_object(obj, word_sz);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
void TenuredGeneration::par_promote_alloc_done(int thread_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  ParGCAllocBufferWithBOT* buf = _alloc_buffers[thread_num];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  buf->retire(true, ParallelGCRetainPLAB);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
void TenuredGeneration::retire_alloc_buffers_before_full_gc() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  if (UseParNewGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    for (uint i = 0; i < ParallelGCThreads; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      _alloc_buffers[i]->retire(true /*end_of_gc*/, false /*retain*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
// Verify that any retained parallel allocation buffers do not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
// intersect with dirty cards.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
void TenuredGeneration::verify_alloc_buffers_clean() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  if (UseParNewGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    for (uint i = 0; i < ParallelGCThreads; i++) {
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   421
      _rs->verify_aligned_region_empty(_alloc_buffers[i]->range());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
}
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   425
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
#else  // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
void TenuredGeneration::retire_alloc_buffers_before_full_gc() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
void TenuredGeneration::verify_alloc_buffers_clean() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   431
bool TenuredGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   432
  size_t available = max_contiguous_available();
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   433
  size_t av_promo  = (size_t)gc_stats()->avg_promoted()->padded_average();
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   434
  bool   res = (available >= av_promo) || (available >= max_promotion_in_bytes);
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   435
  if (PrintGC && Verbose) {
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   436
    gclog_or_tty->print_cr(
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   437
      "Tenured: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT"),"
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   438
      "max_promo("SIZE_FORMAT")",
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   439
      res? "":" not", available, res? ">=":"<",
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   440
      av_promo, max_promotion_in_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  }
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 5547
diff changeset
   442
  return res;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
}