hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp
author johnc
Fri, 21 Dec 2012 11:45:34 -0800
changeset 15089 6becb5b6047a
parent 12382 6aaecb1cbfe1
child 15861 974c3ccaa5d2
permissions -rw-r--r--
8001424: G1: Rename certain G1-specific flags Summary: Rename G1DefaultMinNewGenPercent, G1DefaultMaxNewGenPercent, and G1OldCSetRegionLiveThresholdPercent to G1NewSizePercent, G1MaxNewSizePercent, and G1MixedGCLiveThresholdPercent respectively. The previous names are no longer accepted. Reviewed-by: brutisso, ysr
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     1
/*
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
     2
 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     4
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     7
 * published by the Free Software Foundation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     8
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    13
 * accompanied this code).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    14
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4473
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4473
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: 4473
diff changeset
    21
 * questions.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    22
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    23
 */
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6183
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6183
diff changeset
    26
#include "gc_implementation/g1/collectionSetChooser.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6183
diff changeset
    27
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6183
diff changeset
    28
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
10523
cdb54c167ab0 7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents: 8930
diff changeset
    29
#include "gc_implementation/g1/g1ErgoVerbose.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6183
diff changeset
    30
#include "memory/space.inline.hpp"
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    31
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    32
// Even though we don't use the GC efficiency in our heuristics as
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    33
// much as we used to, we still order according to GC efficiency. This
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    34
// will cause regions with a lot of live objects and large RSets to
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    35
// end up at the end of the array. Given that we might skip collecting
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    36
// the last few old regions, if after a few mixed GCs the remaining
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    37
// have reclaimable bytes under a certain threshold, the hope is that
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    38
// the ones we'll skip are ones with both large RSets and a lot of
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    39
// live objects, not the ones with just a lot of live objects if we
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    40
// ordered according to the amount of reclaimable bytes per region.
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    41
static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    42
  if (hr1 == NULL) {
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    43
    if (hr2 == NULL) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    44
      return 0;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    45
    } else {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    46
      return 1;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    47
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    48
  } else if (hr2 == NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    49
    return -1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    50
  }
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    51
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    52
  double gc_eff1 = hr1->gc_efficiency();
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    53
  double gc_eff2 = hr2->gc_efficiency();
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    54
  if (gc_eff1 > gc_eff2) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    55
    return -1;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    56
  } if (gc_eff1 < gc_eff2) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    57
    return 1;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    58
  } else {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    59
    return 0;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    60
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    61
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    62
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    63
static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    64
  return order_regions(*hr1p, *hr2p);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    65
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    66
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    67
CollectionSetChooser::CollectionSetChooser() :
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    68
  // The line below is the worst bit of C++ hackery I've ever written
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    69
  // (Detlefs, 11/23).  You should think of it as equivalent to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    70
  // "_regions(100, true)": initialize the growable array and inform it
6183
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    71
  // that it should allocate its elem array(s) on the C heap.
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    72
  //
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    73
  // The first argument, however, is actually a comma expression
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    74
  // (set_allocation_type(this, C_HEAP), 100). The purpose of the
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    75
  // set_allocation_type() call is to replace the default allocation
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    76
  // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    77
  // allow to pass the assert in GenericGrowableArray() which checks
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    78
  // that a growable array object must be on C heap if elements are.
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    79
  //
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    80
  // Note: containing object is allocated on C heap since it is CHeapObj.
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5547
diff changeset
    81
  //
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    82
  _regions((ResourceObj::set_allocation_type((address) &_regions,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    83
                                             ResourceObj::C_HEAP),
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    84
                  100), true /* C_Heap */),
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    85
    _curr_index(0), _length(0), _first_par_unreserved_idx(0),
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    86
    _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    87
  _region_live_threshold_bytes =
15089
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 12382
diff changeset
    88
    HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    89
}
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    90
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    91
#ifndef PRODUCT
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    92
void CollectionSetChooser::verify() {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    93
  guarantee(_length <= regions_length(),
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    94
         err_msg("_length: %u regions length: %u", _length, regions_length()));
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    95
  guarantee(_curr_index <= _length,
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    96
            err_msg("_curr_index: %u _length: %u", _curr_index, _length));
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
    97
  uint index = 0;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    98
  size_t sum_of_reclaimable_bytes = 0;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
    99
  while (index < _curr_index) {
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   100
    guarantee(regions_at(index) == NULL,
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   101
              "all entries before _curr_index should be NULL");
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   102
    index += 1;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   103
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   104
  HeapRegion *prev = NULL;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   105
  while (index < _length) {
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   106
    HeapRegion *curr = regions_at(index++);
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   107
    guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
10680
f7bdba11999b 7095236: G1: _markedRegions never contains NULL regions
ysr
parents: 10523
diff changeset
   108
    guarantee(!curr->is_young(), "should not be young!");
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   109
    guarantee(!curr->isHumongous(), "should not be humongous!");
10680
f7bdba11999b 7095236: G1: _markedRegions never contains NULL regions
ysr
parents: 10523
diff changeset
   110
    if (prev != NULL) {
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   111
      guarantee(order_regions(prev, curr) != 1,
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   112
                err_msg("GC eff prev: %1.4f GC eff curr: %1.4f",
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   113
                        prev->gc_efficiency(), curr->gc_efficiency()));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   114
    }
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   115
    sum_of_reclaimable_bytes += curr->reclaimable_bytes();
10680
f7bdba11999b 7095236: G1: _markedRegions never contains NULL regions
ysr
parents: 10523
diff changeset
   116
    prev = curr;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   117
  }
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   118
  guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   119
            err_msg("reclaimable bytes inconsistent, "
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   120
                    "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT,
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   121
                    _remaining_reclaimable_bytes, sum_of_reclaimable_bytes));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   122
}
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   123
#endif // !PRODUCT
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   124
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   125
void CollectionSetChooser::sort_regions() {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   126
  // First trim any unused portion of the top in the parallel case.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   127
  if (_first_par_unreserved_idx > 0) {
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   128
    assert(_first_par_unreserved_idx <= regions_length(),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   129
           "Or we didn't reserved enough length");
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   130
    regions_trunc_to(_first_par_unreserved_idx);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   131
  }
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   132
  _regions.sort(order_regions);
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   133
  assert(_length <= regions_length(), "Requirement");
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   134
#ifdef ASSERT
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   135
  for (uint i = 0; i < _length; i++) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   136
    assert(regions_at(i) != NULL, "Should be true by sorting!");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   137
  }
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   138
#endif // ASSERT
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 7397
diff changeset
   139
  if (G1PrintRegionLivenessInfo) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 7397
diff changeset
   140
    G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting");
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   141
    for (uint i = 0; i < _length; ++i) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   142
      HeapRegion* r = regions_at(i);
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 7397
diff changeset
   143
      cl.doHeapRegion(r);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   144
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   145
  }
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   146
  verify();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   147
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   148
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   149
uint CollectionSetChooser::calc_min_old_cset_length() {
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   150
  // The min old CSet region bound is based on the maximum desired
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   151
  // number of mixed GCs after a cycle. I.e., even if some old regions
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   152
  // look expensive, we should add them to the CSet anyway to make
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   153
  // sure we go through the available old regions in no more than the
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   154
  // maximum desired number of mixed GCs.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   155
  //
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   156
  // The calculation is based on the number of marked regions we added
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   157
  // to the CSet chooser in the first place, not how many remain, so
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   158
  // that the result is the same during all mixed GCs that follow a cycle.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   159
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   160
  const size_t region_num = (size_t) _length;
12228
15ffdb8224fe 7146246: G1: expose some of the -XX flags that drive which old regions to collect during mixed GCs
tonyp
parents: 11756
diff changeset
   161
  const size_t gc_num = (size_t) G1MixedGCCountTarget;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   162
  size_t result = region_num / gc_num;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   163
  // emulate ceiling
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   164
  if (result * gc_num < region_num) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   165
    result += 1;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   166
  }
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12228
diff changeset
   167
  return (uint) result;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   168
}
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   169
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   170
uint CollectionSetChooser::calc_max_old_cset_length() {
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   171
  // The max old CSet region bound is based on the threshold expressed
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   172
  // as a percentage of the heap size. I.e., it should bound the
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   173
  // number of old regions added to the CSet irrespective of how many
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   174
  // of them are available.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   175
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   176
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   177
  const size_t region_num = g1h->n_regions();
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   178
  const size_t perc = (size_t) G1OldCSetRegionThresholdPercent;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   179
  size_t result = region_num * perc / 100;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   180
  // emulate ceiling
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   181
  if (100 * result < region_num * perc) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   182
    result += 1;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   183
  }
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12228
diff changeset
   184
  return (uint) result;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   185
}
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   186
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   187
void CollectionSetChooser::add_region(HeapRegion* hr) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   188
  assert(!hr->isHumongous(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   189
         "Humongous regions shouldn't be added to the collection set");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   190
  assert(!hr->is_young(), "should not be young!");
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   191
  _regions.append(hr);
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   192
  _length++;
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   193
  _remaining_reclaimable_bytes += hr->reclaimable_bytes();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   194
  hr->calc_gc_efficiency();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   195
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   196
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   197
void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions,
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   198
                                                           uint chunk_size) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   199
  _first_par_unreserved_idx = 0;
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12228
diff changeset
   200
  uint n_threads = (uint) ParallelGCThreads;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   201
  if (UseDynamicNumberOfGCThreads) {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   202
    assert(G1CollectedHeap::heap()->workers()->active_workers() > 0,
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   203
      "Should have been set earlier");
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   204
    // This is defensive code. As the assertion above says, the number
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   205
    // of active threads should be > 0, but in case there is some path
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   206
    // or some improperly initialized variable with leads to no
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   207
    // active threads, protect against that in a product build.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   208
    n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(),
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   209
                     1U);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10680
diff changeset
   210
  }
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   211
  uint max_waste = n_threads * chunk_size;
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   212
  // it should be aligned with respect to chunk_size
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   213
  uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size;
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   214
  assert(aligned_n_regions % chunk_size == 0, "should be aligned");
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   215
  regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   216
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   217
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   218
uint CollectionSetChooser::claim_array_chunk(uint chunk_size) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   219
  uint res = (uint) Atomic::add((jint) chunk_size,
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   220
                                (volatile jint*) &_first_par_unreserved_idx);
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   221
  assert(regions_length() > res + chunk_size - 1,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   222
         "Should already have been expanded");
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   223
  return res - chunk_size;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   224
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   225
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   226
void CollectionSetChooser::set_region(uint index, HeapRegion* hr) {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   227
  assert(regions_at(index) == NULL, "precondition");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   228
  assert(!hr->is_young(), "should not be young!");
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   229
  regions_at_put(index, hr);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   230
  hr->calc_gc_efficiency();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   231
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   232
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   233
void CollectionSetChooser::update_totals(uint region_num,
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   234
                                         size_t reclaimable_bytes) {
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   235
  // Only take the lock if we actually need to update the totals.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   236
  if (region_num > 0) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   237
    assert(reclaimable_bytes > 0, "invariant");
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   238
    // We could have just used atomics instead of taking the
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   239
    // lock. However, we currently don't have an atomic add for size_t.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   240
    MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   241
    _length += region_num;
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   242
    _remaining_reclaimable_bytes += reclaimable_bytes;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   243
  } else {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   244
    assert(reclaimable_bytes == 0, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   245
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   246
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   247
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   248
void CollectionSetChooser::clear() {
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   249
  _regions.clear();
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   250
  _curr_index = 0;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   251
  _length = 0;
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
   252
  _remaining_reclaimable_bytes = 0;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11396
diff changeset
   253
};