hotspot/src/share/vm/gc/g1/g1CollectorPolicy.hpp
author ehelin
Sun, 29 Nov 2015 10:00:23 +0100
changeset 34611 b8f6f834489b
parent 34310 32e3c906b613
child 34619 83b1fedf01e9
permissions -rw-r--r--
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser Reviewed-by: mgerdin, tschatzl
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
/*
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
     2
 * Copyright (c) 2001, 2015, 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: 5350
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5350
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: 5350
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
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
    25
#ifndef SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
    26
#define SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6249
diff changeset
    27
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
    28
#include "gc/g1/collectionSetChooser.hpp"
31331
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 30874
diff changeset
    29
#include "gc/g1/g1CollectorState.hpp"
33624
509a72e7127b 8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents: 33591
diff changeset
    30
#include "gc/g1/g1GCPhaseTimes.hpp"
32378
8dd0e7359751 8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents: 31331
diff changeset
    31
#include "gc/g1/g1InCSetState.hpp"
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
    32
#include "gc/g1/g1InitialMarkToMixedTimeTracker.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
    33
#include "gc/g1/g1MMUTracker.hpp"
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
    34
#include "gc/g1/g1Predictions.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
    35
#include "gc/shared/collectorPolicy.hpp"
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
    36
#include "utilities/pair.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6249
diff changeset
    37
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    38
// A G1CollectorPolicy makes policy decisions that determine the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    39
// characteristics of the collector.  Examples include:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    40
//   * choice of collection set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    41
//   * when to collect.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    42
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    43
class HeapRegion;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    44
class CollectionSetChooser;
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
    45
class G1IHOPControl;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    46
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
    47
// TraceYoungGenTime collects data on _both_ young and mixed evacuation pauses
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    48
// (the latter may contain non-young regions - i.e. regions that are
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
    49
// technically in old) while TraceOldGenTime collects data about full GCs.
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
    50
class TraceYoungGenTimeData : public CHeapObj<mtGC> {
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    51
 private:
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    52
  unsigned  _young_pause_num;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    53
  unsigned  _mixed_pause_num;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    54
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    55
  NumberSeq _all_stop_world_times_ms;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    56
  NumberSeq _all_yield_times_ms;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    57
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    58
  NumberSeq _total;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    59
  NumberSeq _other;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    60
  NumberSeq _root_region_scan_wait;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    61
  NumberSeq _parallel;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    62
  NumberSeq _ext_root_scan;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    63
  NumberSeq _satb_filtering;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    64
  NumberSeq _update_rs;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    65
  NumberSeq _scan_rs;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    66
  NumberSeq _obj_copy;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    67
  NumberSeq _termination;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    68
  NumberSeq _parallel_other;
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    69
  NumberSeq _clear_ct;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    70
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
    71
  void print_summary(const char* str, const NumberSeq* seq) const;
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
    72
  void print_summary_sd(const char* str, const NumberSeq* seq) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    73
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    74
public:
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
    75
   TraceYoungGenTimeData() : _young_pause_num(0), _mixed_pause_num(0) {};
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    76
  void record_start_collection(double time_to_stop_the_world_ms);
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    77
  void record_yield_time(double yield_time_ms);
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
    78
  void record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times);
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    79
  void increment_young_collection_count();
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    80
  void increment_mixed_collection_count();
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    81
  void print() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    82
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    83
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
    84
class TraceOldGenTimeData : public CHeapObj<mtGC> {
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    85
 private:
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    86
  NumberSeq _all_full_gc_times;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    87
12781
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    88
 public:
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    89
  void record_full_collection(double full_gc_time_ms);
dd6480eea079 7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents: 12625
diff changeset
    90
  void print() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    91
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    92
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    93
// There are three command line options related to the young gen size:
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    94
// NewSize, MaxNewSize and NewRatio (There is also -Xmn, but that is
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    95
// just a short form for NewSize==MaxNewSize). G1 will use its internal
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    96
// heuristics to calculate the actual young gen size, so these options
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    97
// basically only limit the range within which G1 can pick a young gen
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    98
// size. Also, these are general options taking byte sizes. G1 will
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
    99
// internally work with a number of regions instead. So, some rounding
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   100
// will occur.
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   101
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   102
// If nothing related to the the young gen size is set on the command
15089
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   103
// line we should allow the young gen to be between G1NewSizePercent
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   104
// and G1MaxNewSizePercent of the heap size. This means that every time
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   105
// the heap size changes, the limits for the young gen size will be
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   106
// recalculated.
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   107
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   108
// If only -XX:NewSize is set we should use the specified value as the
15089
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   109
// minimum size for young gen. Still using G1MaxNewSizePercent of the
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   110
// heap as maximum.
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   111
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   112
// If only -XX:MaxNewSize is set we should use the specified value as the
15089
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   113
// maximum size for young gen. Still using G1NewSizePercent of the heap
6becb5b6047a 8001424: G1: Rename certain G1-specific flags
johnc
parents: 13925
diff changeset
   114
// as minimum.
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   115
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   116
// If -XX:NewSize and -XX:MaxNewSize are both specified we use these values.
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   117
// No updates when the heap size changes. There is a special case when
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   118
// NewSize==MaxNewSize. This is interpreted as "fixed" and will use a
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   119
// different heuristic for calculating the collection set when we do mixed
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   120
// collection.
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   121
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   122
// If only -XX:NewRatio is set we should use the specified ratio of the heap
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   123
// as both min and max. This will be interpreted as "fixed" just like the
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   124
// NewSize==MaxNewSize case above. But we will update the min and max
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21561
diff changeset
   125
// every time the heap size changes.
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   126
//
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   127
// NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   128
// combined with either NewSize or MaxNewSize. (A warning message is printed.)
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12781
diff changeset
   129
class G1YoungGenSizer : public CHeapObj<mtGC> {
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   130
private:
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   131
  enum SizerKind {
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   132
    SizerDefaults,
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   133
    SizerNewSizeOnly,
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   134
    SizerMaxNewSizeOnly,
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   135
    SizerMaxAndNewSize,
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   136
    SizerNewRatio
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   137
  };
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   138
  SizerKind _sizer_kind;
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   139
  uint _min_desired_young_length;
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   140
  uint _max_desired_young_length;
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   141
  bool _adaptive_size;
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   142
  uint calculate_default_min_length(uint new_number_of_heap_regions);
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   143
  uint calculate_default_max_length(uint new_number_of_heap_regions);
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   144
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   145
  // Update the given values for minimum and maximum young gen length in regions
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   146
  // given the number of heap regions depending on the kind of sizing algorithm.
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   147
  void recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   148
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   149
public:
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   150
  G1YoungGenSizer();
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   151
  // Calculate the maximum length of the young gen given the number of regions
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   152
  // depending on the sizing algorithm.
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   153
  uint max_young_length(uint number_of_heap_regions);
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   154
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   155
  void heap_size_changed(uint new_number_of_heap_regions);
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   156
  uint min_desired_young_length() {
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   157
    return _min_desired_young_length;
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   158
  }
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   159
  uint max_desired_young_length() {
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   160
    return _max_desired_young_length;
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   161
  }
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   162
  bool adaptive_young_list_length() const {
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   163
    return _adaptive_size;
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   164
  }
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   165
};
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   166
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   167
class G1CollectorPolicy: public CollectorPolicy {
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   168
 private:
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   169
  G1IHOPControl* _ihop_control;
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   170
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   171
  G1IHOPControl* create_ihop_control() const;
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   172
  // Update the IHOP control with necessary statistics.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   173
  void update_ihop_prediction(double mutator_time_s,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   174
                              size_t mutator_alloc_bytes,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   175
                              size_t young_gen_size);
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   176
  void report_ihop_statistics();
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   177
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   178
  G1Predictions _predictor;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   179
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   180
  double get_new_prediction(TruncatedSeq const* seq) const;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   181
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   182
  // either equal to the number of parallel threads, if ParallelGCThreads
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   183
  // has been set, or 1 otherwise
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   184
  int _parallel_gc_threads;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   185
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   186
  // The number of GC threads currently active.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   187
  uintx _no_of_gc_threads;
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   188
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   189
  G1MMUTracker* _mmu_tracker;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   190
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   191
  void initialize_alignments();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   192
  void initialize_flags();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   193
34611
b8f6f834489b 8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents: 34310
diff changeset
   194
  CollectionSetChooser* _cset_chooser;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   195
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   196
  double _full_collection_start_sec;
3590
a268fa66d7fb 6819077: G1: first GC thread coming late into the GC.
johnc
parents: 3191
diff changeset
   197
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   198
  // These exclude marking times.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   199
  TruncatedSeq* _recent_gc_times_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   200
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   201
  TruncatedSeq* _concurrent_mark_remark_times_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   202
  TruncatedSeq* _concurrent_mark_cleanup_times_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   203
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   204
  TraceYoungGenTimeData _trace_young_gen_time_data;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   205
  TraceOldGenTimeData   _trace_old_gen_time_data;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   206
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   207
  double _stop_world_start;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   208
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   209
  uint _young_list_target_length;
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   210
  uint _young_list_fixed_length;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   211
7416
cfe3bfab7d48 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents: 7398
diff changeset
   212
  // The max number of regions we can extend the eden by while the GC
cfe3bfab7d48 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents: 7398
diff changeset
   213
  // locker is active. This should be >= _young_list_target_length;
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   214
  uint _young_list_max_length;
7416
cfe3bfab7d48 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents: 7398
diff changeset
   215
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   216
  SurvRateGroup* _short_lived_surv_rate_group;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   217
  SurvRateGroup* _survivor_surv_rate_group;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   218
  // add here any more surv rate groups
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   219
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   220
  double _gc_overhead_perc;
5240
3892e01609c6 6937160: G1: should observe GCTimeRatio
tonyp
parents: 4481
diff changeset
   221
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   222
  double _reserve_factor;
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 22552
diff changeset
   223
  uint   _reserve_regions;
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   224
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   225
  enum PredictionConstants {
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   226
    TruncatedSeqLength = 10,
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   227
    NumPrevPausesForHeuristics = 10
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   228
  };
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   229
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   230
  TruncatedSeq* _alloc_rate_ms_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   231
  double        _prev_collection_pause_end_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   232
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   233
  TruncatedSeq* _rs_length_diff_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   234
  TruncatedSeq* _cost_per_card_ms_seq;
33204
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33130
diff changeset
   235
  TruncatedSeq* _cost_scan_hcc_seq;
11249
b0c1cc35cafe 7113012: G1: rename not-fully-young GCs as "mixed"
tonyp
parents: 11176
diff changeset
   236
  TruncatedSeq* _young_cards_per_entry_ratio_seq;
b0c1cc35cafe 7113012: G1: rename not-fully-young GCs as "mixed"
tonyp
parents: 11176
diff changeset
   237
  TruncatedSeq* _mixed_cards_per_entry_ratio_seq;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   238
  TruncatedSeq* _cost_per_entry_ms_seq;
11249
b0c1cc35cafe 7113012: G1: rename not-fully-young GCs as "mixed"
tonyp
parents: 11176
diff changeset
   239
  TruncatedSeq* _mixed_cost_per_entry_ms_seq;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   240
  TruncatedSeq* _cost_per_byte_ms_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   241
  TruncatedSeq* _constant_other_time_ms_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   242
  TruncatedSeq* _young_other_cost_per_region_ms_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   243
  TruncatedSeq* _non_young_other_cost_per_region_ms_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   244
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   245
  TruncatedSeq* _pending_cards_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   246
  TruncatedSeq* _rs_lengths_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   247
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   248
  TruncatedSeq* _cost_per_byte_ms_during_cm_seq;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   249
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   250
  G1YoungGenSizer* _young_gen_sizer;
10529
9d5bbffbb322 6929868: G1: introduce min / max young gen size bounds
brutisso
parents: 10528
diff changeset
   251
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   252
  uint _eden_cset_region_length;
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   253
  uint _survivor_cset_region_length;
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   254
  uint _old_cset_region_length;
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   255
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   256
  void init_cset_region_lengths(uint eden_cset_region_length,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   257
                                uint survivor_cset_region_length);
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   258
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   259
  uint eden_cset_region_length() const     { return _eden_cset_region_length;     }
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   260
  uint survivor_cset_region_length() const { return _survivor_cset_region_length; }
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   261
  uint old_cset_region_length() const      { return _old_cset_region_length;      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   262
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   263
  uint _free_regions_at_end_of_collection;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   264
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   265
  size_t _recorded_rs_lengths;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   266
  size_t _max_rs_lengths;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   267
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   268
  size_t _rs_lengths_prediction;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   269
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   270
#ifndef PRODUCT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   271
  bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   272
#endif // PRODUCT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   273
4481
de92ec484f5e 6862387: tune concurrent refinement further
iveresov
parents: 3697
diff changeset
   274
  void adjust_concurrent_refinement(double update_rs_time,
de92ec484f5e 6862387: tune concurrent refinement further
iveresov
parents: 3697
diff changeset
   275
                                    double update_rs_processed_buffers,
de92ec484f5e 6862387: tune concurrent refinement further
iveresov
parents: 3697
diff changeset
   276
                                    double goal_ms);
de92ec484f5e 6862387: tune concurrent refinement further
iveresov
parents: 3697
diff changeset
   277
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   278
  uintx no_of_gc_threads() { return _no_of_gc_threads; }
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   279
  void set_no_of_gc_threads(uintx v) { _no_of_gc_threads = v; }
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   280
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   281
  double _pause_time_target_ms;
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   282
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   283
  size_t _pending_cards;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   284
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   285
  // The amount of allocated bytes in old gen during the last mutator and the following
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   286
  // young GC phase.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   287
  size_t _bytes_allocated_in_old_since_last_gc;
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   288
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   289
  G1InitialMarkToMixedTimeTracker _initial_mark_to_mixed;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   290
public:
34132
aa73af640c61 8142403: Make G1CollectorPolicy::predictor const
ehelin
parents: 33810
diff changeset
   291
  const G1Predictions& predictor() const { return _predictor; }
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   292
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   293
  // Add the given number of bytes to the total number of allocated bytes in the old gen.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   294
  void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   295
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
   296
  // Accessors
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   297
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   298
  void set_region_eden(HeapRegion* hr, int young_index_in_cset) {
26696
623a25e6c686 8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents: 24941
diff changeset
   299
    hr->set_eden();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   300
    hr->install_surv_rate_group(_short_lived_surv_rate_group);
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   301
    hr->set_young_index_in_cset(young_index_in_cset);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   302
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   303
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   304
  void set_region_survivor(HeapRegion* hr, int young_index_in_cset) {
26696
623a25e6c686 8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents: 24941
diff changeset
   305
    assert(hr->is_survivor(), "pre-condition");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   306
    hr->install_surv_rate_group(_survivor_surv_rate_group);
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   307
    hr->set_young_index_in_cset(young_index_in_cset);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   308
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   309
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   310
#ifndef PRODUCT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   311
  bool verify_young_ages();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   312
#endif // PRODUCT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   313
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   314
  void record_max_rs_lengths(size_t rs_lengths) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   315
    _max_rs_lengths = rs_lengths;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   316
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   317
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   318
  size_t predict_rs_length_diff() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   319
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   320
  double predict_alloc_rate_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   321
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   322
  double predict_cost_per_card_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   323
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   324
  double predict_scan_hcc_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   325
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   326
  double predict_rs_update_time_ms(size_t pending_cards) const;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   327
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   328
  double predict_young_cards_per_entry_ratio() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   329
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   330
  double predict_mixed_cards_per_entry_ratio() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   331
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   332
  size_t predict_young_card_num(size_t rs_length) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   333
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   334
  size_t predict_non_young_card_num(size_t rs_length) const;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   335
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   336
  double predict_rs_scan_time_ms(size_t card_num) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   337
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   338
  double predict_mixed_rs_scan_time_ms(size_t card_num) const;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   339
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   340
  double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   341
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   342
  double predict_object_copy_time_ms(size_t bytes_to_copy) const;
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   343
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   344
  double predict_constant_other_time_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   345
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   346
  double predict_young_other_time_ms(size_t young_num) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   347
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   348
  double predict_non_young_other_time_ms(size_t non_young_num) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   349
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   350
  double predict_base_elapsed_time_ms(size_t pending_cards) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   351
  double predict_base_elapsed_time_ms(size_t pending_cards,
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   352
                                      size_t scanned_cards) const;
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   353
  size_t predict_bytes_to_copy(HeapRegion* hr) const;
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   354
  double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   355
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   356
  void set_recorded_rs_lengths(size_t rs_lengths);
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   357
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   358
  uint cset_region_length() const       { return young_cset_region_length() +
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   359
                                           old_cset_region_length(); }
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   360
  uint young_cset_region_length() const { return eden_cset_region_length() +
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   361
                                           survivor_cset_region_length(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   362
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   363
  double predict_survivor_regions_evac_time() const;
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   364
33216
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   365
  bool should_update_surv_rate_group_predictors() {
33217
866a541f5504 8138752: G1CollectorPolicy::should_should_update_surv_rate_group_predictors() uses wrong predicate
tschatzl
parents: 33216
diff changeset
   366
    return collector_state()->last_gc_was_young() && !collector_state()->in_marking_window();
33216
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   367
  }
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   368
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   369
  void cset_regions_freed() {
33216
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   370
    bool update = should_update_surv_rate_group_predictors();
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   371
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   372
    _short_lived_surv_rate_group->all_surviving_words_recorded(update);
8ecefd0f0d10 8138750: Remove dead code in survivor rate group
tschatzl
parents: 33214
diff changeset
   373
    _survivor_surv_rate_group->all_surviving_words_recorded(update);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   374
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   375
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   376
  G1MMUTracker* mmu_tracker() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   377
    return _mmu_tracker;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   378
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   379
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   380
  const G1MMUTracker* mmu_tracker() const {
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   381
    return _mmu_tracker;
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   382
  }
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   383
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   384
  double max_pause_time_ms() const {
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   385
    return _mmu_tracker->max_gc_time() * 1000.0;
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   386
  }
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   387
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   388
  double predict_remark_time_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   389
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   390
  double predict_cleanup_time_ms() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   391
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   392
  // Returns an estimate of the survival rate of the region at yg-age
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   393
  // "yg_age".
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   394
  double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   395
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   396
  double predict_yg_surv_rate(int age) const;
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   397
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   398
  double accum_yg_surv_rate_pred(int age) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   399
33624
509a72e7127b 8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents: 33591
diff changeset
   400
protected:
509a72e7127b 8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents: 33591
diff changeset
   401
  virtual double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;
33747
2dfa9256eb77 8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents: 33739
diff changeset
   402
  virtual double other_time_ms(double pause_time_ms) const;
2dfa9256eb77 8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents: 33739
diff changeset
   403
2dfa9256eb77 8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents: 33739
diff changeset
   404
  double young_other_time_ms() const;
2dfa9256eb77 8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents: 33739
diff changeset
   405
  double non_young_other_time_ms() const;
2dfa9256eb77 8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents: 33739
diff changeset
   406
  double constant_other_time_ms(double pause_time_ms) const;
33624
509a72e7127b 8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents: 33591
diff changeset
   407
34611
b8f6f834489b 8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents: 34310
diff changeset
   408
  CollectionSetChooser* cset_chooser() const {
b8f6f834489b 8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents: 34310
diff changeset
   409
    return _cset_chooser;
b8f6f834489b 8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents: 34310
diff changeset
   410
  }
b8f6f834489b 8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents: 34310
diff changeset
   411
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   412
private:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   413
  // Statistics kept per GC stoppage, pause or full.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   414
  TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   415
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   416
  // Add a new GC of the given duration and end time to the record.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   417
  void update_recent_gc_times(double end_time_sec, double elapsed_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   418
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   419
  // The head of the list (via "next_in_collection_set()") representing the
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   420
  // current collection set. Set from the incrementally built collection
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   421
  // set at the start of the pause.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   422
  HeapRegion* _collection_set;
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   423
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   424
  // The number of bytes in the collection set before the pause. Set from
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   425
  // the incrementally built collection set at the start of an evacuation
32744
3628aefe13d5 8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents: 32737
diff changeset
   426
  // pause, and incremented in finalize_old_cset_part() when adding old regions
13482
c6b6960549f1 7185699: G1: Prediction model discrepancies
johnc
parents: 13289
diff changeset
   427
  // (if any) to the collection set.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   428
  size_t _collection_set_bytes_used_before;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   429
13482
c6b6960549f1 7185699: G1: Prediction model discrepancies
johnc
parents: 13289
diff changeset
   430
  // The number of bytes copied during the GC.
c6b6960549f1 7185699: G1: Prediction model discrepancies
johnc
parents: 13289
diff changeset
   431
  size_t _bytes_copied_during_gc;
c6b6960549f1 7185699: G1: Prediction model discrepancies
johnc
parents: 13289
diff changeset
   432
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   433
  // The associated information that is maintained while the incremental
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   434
  // collection set is being built with young regions. Used to populate
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   435
  // the recorded info for the evacuation pause.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   436
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   437
  enum CSetBuildType {
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   438
    Active,             // We are actively building the collection set
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   439
    Inactive            // We are not actively building the collection set
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   440
  };
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   441
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   442
  CSetBuildType _inc_cset_build_state;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   443
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   444
  // The head of the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   445
  HeapRegion* _inc_cset_head;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   446
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   447
  // The tail of the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   448
  HeapRegion* _inc_cset_tail;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   449
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   450
  // The number of bytes in the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   451
  // Used to set _collection_set_bytes_used_before at the start of
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   452
  // an evacuation pause.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   453
  size_t _inc_cset_bytes_used_before;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   454
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   455
  // Used to record the highest end of heap region in collection set
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   456
  HeapWord* _inc_cset_max_finger;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   457
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   458
  // The RSet lengths recorded for regions in the CSet. It is updated
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   459
  // by the thread that adds a new region to the CSet. We assume that
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   460
  // only one thread can be allocating a new CSet region (currently,
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   461
  // it does so after taking the Heap_lock) hence no need to
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   462
  // synchronize updates to this field.
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   463
  size_t _inc_cset_recorded_rs_lengths;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   464
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21561
diff changeset
   465
  // A concurrent refinement thread periodically samples the young
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   466
  // region RSets and needs to update _inc_cset_recorded_rs_lengths as
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21561
diff changeset
   467
  // the RSets grow. Instead of having to synchronize updates to that
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   468
  // field we accumulate them in this field and add it to
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   469
  // _inc_cset_recorded_rs_lengths_diffs at the start of a GC.
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   470
  ssize_t _inc_cset_recorded_rs_lengths_diffs;
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   471
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   472
  // The predicted elapsed time it will take to collect the regions in
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   473
  // the CSet. This is updated by the thread that adds a new region to
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   474
  // the CSet. See the comment for _inc_cset_recorded_rs_lengths about
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   475
  // MT-safety assumptions.
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   476
  double _inc_cset_predicted_elapsed_time_ms;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   477
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   478
  // See the comment for _inc_cset_recorded_rs_lengths_diffs.
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   479
  double _inc_cset_predicted_elapsed_time_ms_diffs;
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   480
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   481
  // Stash a pointer to the g1 heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   482
  G1CollectedHeap* _g1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   483
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   484
  G1GCPhaseTimes* _phase_times;
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   485
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   486
  // The ratio of gc time to elapsed time, computed over recent pauses.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   487
  double _recent_avg_pause_time_ratio;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   488
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   489
  double recent_avg_pause_time_ratio() const {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   490
    return _recent_avg_pause_time_ratio;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   491
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   492
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   493
  // This set of variables tracks the collector efficiency, in order to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   494
  // determine whether we should initiate a new marking.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   495
  double _cur_mark_stop_world_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   496
  double _mark_remark_start_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   497
  double _mark_cleanup_start_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   498
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   499
  // Updates the internal young list maximum and target lengths. Returns the
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   500
  // unbounded young list target length.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   501
  uint update_young_list_max_and_target_length();
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   502
  uint update_young_list_max_and_target_length(size_t rs_lengths);
33591
4a2823c696ce 8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents: 33217
diff changeset
   503
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   504
  // Update the young list target length either by setting it to the
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   505
  // desired fixed value or by calculating it using G1's pause
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   506
  // prediction model. If no rs_lengths parameter is passed, predict
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   507
  // the RS lengths using the prediction model, otherwise use the
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   508
  // given rs_lengths as the prediction.
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   509
  // Returns the unbounded young list target length.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   510
  uint update_young_list_target_length(size_t rs_lengths);
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   511
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   512
  // Calculate and return the minimum desired young list target
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   513
  // length. This is the minimum desired young list length according
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   514
  // to the user's inputs.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   515
  uint calculate_young_list_desired_min_length(uint base_min_length) const;
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   516
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   517
  // Calculate and return the maximum desired young list target
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   518
  // length. This is the maximum desired young list length according
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   519
  // to the user's inputs.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   520
  uint calculate_young_list_desired_max_length() const;
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   521
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   522
  // Calculate and return the maximum young list target length that
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   523
  // can fit into the pause time goal. The parameters are: rs_lengths
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   524
  // represent the prediction of how large the young RSet lengths will
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21561
diff changeset
   525
  // be, base_min_length is the already existing number of regions in
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   526
  // the young list, min_length and max_length are the desired min and
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   527
  // max young list length according to the user's inputs.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   528
  uint calculate_young_list_target_length(size_t rs_lengths,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   529
                                          uint base_min_length,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   530
                                          uint desired_min_length,
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   531
                                          uint desired_max_length) const;
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   532
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   533
  // Result of the bounded_young_list_target_length() method, containing both the
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   534
  // bounded as well as the unbounded young list target lengths in this order.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   535
  typedef Pair<uint, uint, StackObj> YoungTargetLengths;
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   536
  YoungTargetLengths young_list_target_lengths(size_t rs_lengths) const;
33591
4a2823c696ce 8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents: 33217
diff changeset
   537
4a2823c696ce 8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents: 33217
diff changeset
   538
  void update_rs_lengths_prediction();
4a2823c696ce 8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents: 33217
diff changeset
   539
  void update_rs_lengths_prediction(size_t prediction);
4a2823c696ce 8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents: 33217
diff changeset
   540
27626
5dad25da637c 8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents: 26696
diff changeset
   541
  // Calculate and return chunk size (in number of regions) for parallel
5dad25da637c 8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents: 26696
diff changeset
   542
  // concurrent mark cleanup.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   543
  uint calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const;
27626
5dad25da637c 8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents: 26696
diff changeset
   544
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   545
  // Check whether a given young length (young_length) fits into the
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   546
  // given target pause time and whether the prediction for the amount
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   547
  // of objects to be copied for the given length will fit into the
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   548
  // given free space (expressed by base_free_regions).  It is used by
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   549
  // calculate_young_list_target_length().
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   550
  bool predict_will_fit(uint young_length, double base_time_ms,
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   551
                        uint base_free_regions, double target_pause_time_ms) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   552
15861
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   553
  // Calculate the minimum number of old regions we'll add to the CSet
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   554
  // during a mixed GC.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   555
  uint calc_min_old_cset_length() const;
15861
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   556
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   557
  // Calculate the maximum number of old regions we'll add to the CSet
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   558
  // during a mixed GC.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   559
  uint calc_max_old_cset_length() const;
15861
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   560
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   561
  // Returns the given amount of uncollected reclaimable space
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   562
  // as a percentage of the current heap capacity.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   563
  double reclaimable_bytes_perc(size_t reclaimable_bytes) const;
15861
974c3ccaa5d2 8007036: G1: Too many old regions added to last mixed GC
johnc
parents: 15089
diff changeset
   564
33810
8bbfb74d1f6c 8138740: Start initial mark right after mixed GC if needed
tschatzl
parents: 33808
diff changeset
   565
  // Sets up marking if proper conditions are met.
8bbfb74d1f6c 8138740: Start initial mark right after mixed GC if needed
tschatzl
parents: 33808
diff changeset
   566
  void maybe_start_marking();
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   567
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   568
  // The kind of STW pause.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   569
  enum PauseKind {
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   570
    FullGC,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   571
    YoungOnlyGC,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   572
    MixedGC,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   573
    LastYoungGC,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   574
    InitialMarkGC,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   575
    Cleanup,
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   576
    Remark
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   577
  };
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   578
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   579
  // Calculate PauseKind from internal state.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   580
  PauseKind young_gc_pause_kind() const;
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   581
  // Record the given STW pause with the given start and end times (in s).
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   582
  void record_pause(PauseKind kind, double start, double end);
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   583
  // Indicate that we aborted marking before doing any mixed GCs.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   584
  void abort_time_to_mixed_tracking();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   585
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   586
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   587
  G1CollectorPolicy();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   588
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   589
  virtual ~G1CollectorPolicy();
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34132
diff changeset
   590
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   591
  virtual G1CollectorPolicy* as_g1_policy() { return this; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   592
33214
5a00fba36171 8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents: 33204
diff changeset
   593
  G1CollectorState* collector_state() const;
31331
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 30874
diff changeset
   594
13288
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   595
  G1GCPhaseTimes* phase_times() const { return _phase_times; }
331d5b6725f3 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents: 12781
diff changeset
   596
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   597
  // Check the current value of the young list RSet lengths and
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   598
  // compare it against the last prediction. If the current value is
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   599
  // higher, recalculate the young list target length prediction.
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   600
  void revise_young_list_target_length_if_necessary();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   601
10529
9d5bbffbb322 6929868: G1: introduce min / max young gen size bounds
brutisso
parents: 10528
diff changeset
   602
  // This should be called after the heap is resized.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   603
  void record_new_heap_size(uint new_number_of_regions);
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   604
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   605
  void init();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   606
33739
e1df46512ae2 8140509: Add note_gc_start to G1CollectorPolicy
ehelin
parents: 33738
diff changeset
   607
  virtual void note_gc_start(uint num_active_workers);
e1df46512ae2 8140509: Add note_gc_start to G1CollectorPolicy
ehelin
parents: 33738
diff changeset
   608
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   609
  // Create jstat counters for the policy.
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   610
  virtual void initialize_gc_policy_counters();
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   611
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   612
  virtual HeapWord* mem_allocate_work(size_t size,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   613
                                      bool is_tlab,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   614
                                      bool* gc_overhead_limit_was_exceeded);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   615
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   616
  // This method controls how a collector handles one or more
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   617
  // of its generations being fully allocated.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   618
  virtual HeapWord* satisfy_failed_allocation(size_t size,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   619
                                              bool is_tlab);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   620
11581
b1afc51ad34e 7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents: 11576
diff changeset
   621
  bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0);
11576
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
   622
33808
ee899178e46b 8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents: 33747
diff changeset
   623
  bool about_to_start_mixed_phase() const;
ee899178e46b 8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents: 33747
diff changeset
   624
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   625
  // Record the start and end of an evacuation pause.
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   626
  void record_collection_pause_start(double start_time_sec);
32737
f02118695c2f 8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents: 32736
diff changeset
   627
  void record_collection_pause_end(double pause_time_ms, size_t cards_scanned);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   628
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   629
  // Record the start and end of a full collection.
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   630
  void record_full_collection_start();
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   631
  void record_full_collection_end();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   632
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   633
  // Must currently be called while the world is stopped.
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   634
  void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   635
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   636
  // Record start and end of remark.
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   637
  void record_concurrent_mark_remark_start();
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   638
  void record_concurrent_mark_remark_end();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   639
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   640
  // Record start, end, and completion of cleanup.
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   641
  void record_concurrent_mark_cleanup_start();
30874
18714bae50db 8080837: Move number of workers calculation out of CollectionSetChooser::prepare_for_par_region_addition
stefank
parents: 30764
diff changeset
   642
  void record_concurrent_mark_cleanup_end();
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   643
  void record_concurrent_mark_cleanup_completed();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   644
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   645
  // Records the information about the heap size for reporting in
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   646
  // print_detailed_heap_transition
17396
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   647
  void record_heap_size_info_at_start(bool full);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   648
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   649
  // Print heap sizing transition (with less and more detail).
29795
984c5c379c6a 8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents: 28213
diff changeset
   650
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   651
  void print_heap_transition(size_t bytes_before) const;
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   652
  void print_heap_transition() const;
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   653
  void print_detailed_heap_transition(bool full = false) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   654
33738
1708291bd3d7 8140508: Add utility method for logging phases to G1CollectorPolicy
ehelin
parents: 33624
diff changeset
   655
  virtual void print_phases(double pause_time_sec);
1708291bd3d7 8140508: Add utility method for logging phases to G1CollectorPolicy
ehelin
parents: 33624
diff changeset
   656
16993
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   657
  void record_stop_world_start();
c9fd6b7ef40e 8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents: 15861
diff changeset
   658
  void record_concurrent_pause();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   659
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   660
  // Record how much space we copied during a GC. This is typically
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   661
  // called when a GC alloc region is being retired.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   662
  void record_bytes_copied_during_gc(size_t bytes) {
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   663
    _bytes_copied_during_gc += bytes;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   664
  }
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   665
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   666
  // The amount of space we copied during a GC.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   667
  size_t bytes_copied_during_gc() const {
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   668
    return _bytes_copied_during_gc;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   669
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   670
32591
b4acfa743bb6 8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents: 32378
diff changeset
   671
  size_t collection_set_bytes_used_before() const {
b4acfa743bb6 8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents: 32378
diff changeset
   672
    return _collection_set_bytes_used_before;
b4acfa743bb6 8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents: 32378
diff changeset
   673
  }
b4acfa743bb6 8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents: 32378
diff changeset
   674
12236
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 11756
diff changeset
   675
  // Determine whether there are candidate regions so that the
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 11756
diff changeset
   676
  // next GC should be mixed. The two action strings are used
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 11756
diff changeset
   677
  // in the ergo output when the method returns true or false.
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11584
diff changeset
   678
  bool next_gc_should_be_mixed(const char* true_action_str,
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   679
                               const char* false_action_str) const;
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11584
diff changeset
   680
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   681
  // Choose a new collection set.  Marks the chosen regions as being
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   682
  // "in_collection_set", and links them together.  The head and number of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   683
  // the collection set are available via access methods.
32744
3628aefe13d5 8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents: 32737
diff changeset
   684
  double finalize_young_cset_part(double target_pause_time_ms);
3628aefe13d5 8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents: 32737
diff changeset
   685
  virtual void finalize_old_cset_part(double time_remaining_ms);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   686
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   687
  // The head of the list (via "next_in_collection_set()") representing the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   688
  // current collection set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   689
  HeapRegion* collection_set() { return _collection_set; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   690
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   691
  void clear_collection_set() { _collection_set = NULL; }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   692
11169
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   693
  // Add old region "hr" to the CSet.
0cfe4d79060c 7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents: 10770
diff changeset
   694
  void add_old_region_to_cset(HeapRegion* hr);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   695
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   696
  // Incremental CSet Support
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   697
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   698
  // The head of the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   699
  HeapRegion* inc_cset_head() { return _inc_cset_head; }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   700
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   701
  // The tail of the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   702
  HeapRegion* inc_set_tail() { return _inc_cset_tail; }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   703
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   704
  // Initialize incremental collection set info.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   705
  void start_incremental_cset_building();
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   706
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   707
  // Perform any final calculations on the incremental CSet fields
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   708
  // before we can use them.
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   709
  void finalize_incremental_cset_building();
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   710
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   711
  void clear_incremental_cset() {
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   712
    _inc_cset_head = NULL;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   713
    _inc_cset_tail = NULL;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   714
  }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   715
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   716
  // Stop adding regions to the incremental collection set
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   717
  void stop_incremental_cset_building() { _inc_cset_build_state = Inactive; }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   718
11395
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   719
  // Add information about hr to the aggregated information for the
33260c27554b 7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents: 11249
diff changeset
   720
  // incrementally built collection set.
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   721
  void add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   722
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   723
  // Update information about hr in the aggregated information for
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   724
  // the incrementally built collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   725
  void update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   726
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   727
private:
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   728
  // Update the incremental cset information when adding a region
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   729
  // (should not be called directly).
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   730
  void add_region_to_incremental_cset_common(HeapRegion* hr);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   731
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   732
public:
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   733
  // Add hr to the LHS of the incremental collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   734
  void add_region_to_incremental_cset_lhs(HeapRegion* hr);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   735
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   736
  // Add hr to the RHS of the incremental collection set.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   737
  void add_region_to_incremental_cset_rhs(HeapRegion* hr);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   738
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   739
#ifndef PRODUCT
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   740
  void print_collection_set(HeapRegion* list_head, outputStream* st);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   741
#endif // !PRODUCT
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5243
diff changeset
   742
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   743
  // This sets the initiate_conc_mark_if_possible() flag to start a
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   744
  // new cycle, as long as we are not already in one. It's best if it
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   745
  // is called during a safepoint when the test whether a cycle is in
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   746
  // progress or not is stable.
10523
cdb54c167ab0 7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents: 10281
diff changeset
   747
  bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   748
5243
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   749
  // This is called at the very beginning of an evacuation pause (it
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   750
  // has to be the first thing that the pause does). If
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   751
  // initiate_conc_mark_if_possible() is true, and the concurrent
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   752
  // marking thread has completed its work during the previous cycle,
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   753
  // it will set during_initial_mark_pause() to so that the pause does
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   754
  // the initial-mark work and start a marking cycle.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5240
diff changeset
   755
  void decide_on_conc_mark_initiation();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   756
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   757
  // If an expansion would be appropriate, because recent GC overhead had
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   758
  // exceeded the desired limit, return an amount to expand by.
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   759
  virtual size_t expansion_amount() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   760
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   761
  // Print tracing information.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   762
  void print_tracing_info() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   763
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   764
  // Print stats on young survival ratio
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   765
  void print_yg_surv_rate_info() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   766
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   767
  void finished_recalculating_age_indexes(bool is_survivors) {
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   768
    if (is_survivors) {
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   769
      _survivor_surv_rate_group->finished_recalculating_age_indexes();
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   770
    } else {
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   771
      _short_lived_surv_rate_group->finished_recalculating_age_indexes();
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   772
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   773
    // do that for any other surv rate groups
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   774
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   775
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
   776
  size_t young_list_target_length() const { return _young_list_target_length; }
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
   777
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   778
  bool is_young_list_full() const;
7416
cfe3bfab7d48 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents: 7398
diff changeset
   779
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   780
  bool can_expand_young_list() const;
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   781
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   782
  uint young_list_max_length() const {
10671
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   783
    return _young_list_max_length;
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   784
  }
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   785
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   786
  bool adaptive_young_list_length() const {
11397
7dc5c8f572b0 7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents: 11395
diff changeset
   787
    return _young_gen_sizer->adaptive_young_list_length();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   788
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   789
34310
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34298
diff changeset
   790
  virtual bool should_process_references() const {
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34298
diff changeset
   791
    return true;
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34298
diff changeset
   792
  }
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34298
diff changeset
   793
10746
96f50959f650 7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents: 10671
diff changeset
   794
private:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   795
  //
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   796
  // Survivor regions policy.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   797
  //
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   798
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   799
  // Current tenuring threshold, set to 0 if the collector reaches the
13925
37f75ba502b1 8000351: Tenuring threshold should be unsigned
jwilhelm
parents: 13728
diff changeset
   800
  // maximum amount of survivors regions.
37f75ba502b1 8000351: Tenuring threshold should be unsigned
jwilhelm
parents: 13728
diff changeset
   801
  uint _tenuring_threshold;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   802
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   803
  // The limit on the number of regions allocated for survivors.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   804
  uint _max_survivor_regions;
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   805
9987
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 8925
diff changeset
   806
  // For reporting purposes.
17396
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   807
  // The value of _heap_bytes_before_gc is also used to calculate
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   808
  // the cost of copying.
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   809
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   810
  size_t _eden_used_bytes_before_gc;         // Eden occupancy before GC
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   811
  size_t _survivor_used_bytes_before_gc;     // Survivor occupancy before GC
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   812
  size_t _heap_used_bytes_before_gc;         // Heap occupancy before GC
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   813
  size_t _metaspace_used_bytes_before_gc;    // Metaspace occupancy before GC
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   814
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   815
  size_t _eden_capacity_bytes_before_gc;     // Eden capacity before GC
4d281f3a57bf 8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents: 16993
diff changeset
   816
  size_t _heap_capacity_bytes_before_gc;     // Heap capacity before GC
9987
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 8925
diff changeset
   817
13925
37f75ba502b1 8000351: Tenuring threshold should be unsigned
jwilhelm
parents: 13728
diff changeset
   818
  // The amount of survivor regions after a collection.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   819
  uint _recorded_survivor_regions;
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   820
  // List of survivor regions.
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   821
  HeapRegion* _recorded_survivor_head;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   822
  HeapRegion* _recorded_survivor_tail;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   823
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   824
  ageTable _survivors_age_table;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   825
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   826
public:
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17396
diff changeset
   827
  uint tenuring_threshold() const { return _tenuring_threshold; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   828
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   829
  static const uint REGIONS_UNLIMITED = (uint) -1;
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   830
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   831
  uint max_regions(InCSetState dest) const {
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   832
    switch (dest.value()) {
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   833
      case InCSetState::Young:
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   834
        return _max_survivor_regions;
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   835
      case InCSetState::Old:
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   836
        return REGIONS_UNLIMITED;
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   837
      default:
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32744
diff changeset
   838
        assert(false, "Unknown dest state: " CSETSTATE_FORMAT, dest.value());
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   839
        break;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   840
    }
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   841
    // keep some compilers happy
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 27892
diff changeset
   842
    return 0;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   843
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   844
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   845
  void note_start_adding_survivor_regions() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   846
    _survivor_surv_rate_group->start_adding_regions();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   847
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   848
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   849
  void note_stop_adding_survivor_regions() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   850
    _survivor_surv_rate_group->stop_adding_regions();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   851
  }
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   852
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12272
diff changeset
   853
  void record_survivor_regions(uint regions,
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   854
                               HeapRegion* head,
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   855
                               HeapRegion* tail) {
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   856
    _recorded_survivor_regions = regions;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   857
    _recorded_survivor_head    = head;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   858
    _recorded_survivor_tail    = tail;
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   859
  }
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   860
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33105
diff changeset
   861
  uint recorded_survivor_regions() const {
3191
dd3cc90b9951 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents: 2881
diff changeset
   862
    return _recorded_survivor_regions;
dd3cc90b9951 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents: 2881
diff changeset
   863
  }
dd3cc90b9951 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents: 2881
diff changeset
   864
32736
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32603
diff changeset
   865
  void record_age_table(ageTable* age_table) {
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32603
diff changeset
   866
    _survivors_age_table.merge(age_table);
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   867
  }
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   868
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   869
  void update_max_gc_locker_expansion();
7416
cfe3bfab7d48 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents: 7398
diff changeset
   870
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   871
  // Calculates survivor space parameters.
10528
06fab03478df 7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents: 10523
diff changeset
   872
  void update_survivors_policy();
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1374
diff changeset
   873
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   874
  virtual void post_heap_initialize();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   875
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   876
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29795
diff changeset
   877
#endif // SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP