hotspot/src/share/vm/gc/g1/g1CollectedHeap.hpp
author tschatzl
Tue, 19 Jul 2016 10:31:41 +0200
changeset 39979 b17e445924da
parent 39698 4016de4e596b
child 40892 330a02d935ad
permissions -rw-r--r--
8034842: Parallelize the Free CSet phase in G1 Reviewed-by: jmasa, ehelin
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
/*
35943
e726308008c0 8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents: 35909
diff changeset
     2
 * Copyright (c) 2001, 2016, 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: 30586
diff changeset
    25
#ifndef SHARE_VM_GC_G1_G1COLLECTEDHEAP_HPP
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    26
#define SHARE_VM_GC_G1_G1COLLECTEDHEAP_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    27
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    28
#include "gc/g1/evacuationInfo.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    29
#include "gc/g1/g1AllocationContext.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    30
#include "gc/g1/g1BiasedArray.hpp"
37039
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
    31
#include "gc/g1/g1CollectionSet.hpp"
31331
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
    32
#include "gc/g1/g1CollectorState.hpp"
35943
e726308008c0 8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents: 35909
diff changeset
    33
#include "gc/g1/g1ConcurrentMark.hpp"
38186
ccaa890f8617 8155943: Move G1Eden/SurvivorRegions into their own source files
mgerdin
parents: 38183
diff changeset
    34
#include "gc/g1/g1EdenRegions.hpp"
ccaa890f8617 8155943: Move G1Eden/SurvivorRegions into their own source files
mgerdin
parents: 38183
diff changeset
    35
#include "gc/g1/g1EvacFailure.hpp"
ccaa890f8617 8155943: Move G1Eden/SurvivorRegions into their own source files
mgerdin
parents: 38183
diff changeset
    36
#include "gc/g1/g1EvacStats.hpp"
ccaa890f8617 8155943: Move G1Eden/SurvivorRegions into their own source files
mgerdin
parents: 38183
diff changeset
    37
#include "gc/g1/g1HeapVerifier.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    38
#include "gc/g1/g1HRPrinter.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    39
#include "gc/g1/g1InCSetState.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    40
#include "gc/g1/g1MonitoringSupport.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    41
#include "gc/g1/g1SATBCardTableModRefBS.hpp"
38186
ccaa890f8617 8155943: Move G1Eden/SurvivorRegions into their own source files
mgerdin
parents: 38183
diff changeset
    42
#include "gc/g1/g1SurvivorRegions.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    43
#include "gc/g1/g1YCTypes.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    44
#include "gc/g1/hSpaceCounters.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    45
#include "gc/g1/heapRegionManager.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    46
#include "gc/g1/heapRegionSet.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    47
#include "gc/shared/barrierSet.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
    48
#include "gc/shared/collectedHeap.hpp"
32378
8dd0e7359751 8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents: 32360
diff changeset
    49
#include "gc/shared/plab.hpp"
38081
a3bcb7197d45 8151556: Use the PreservedMarks* classes for the G1 preserved mark stacks
tonyp
parents: 37989
diff changeset
    50
#include "gc/shared/preservedMarks.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    51
#include "memory/memRegion.hpp"
15608
a1fd1fc60c7d 8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents: 13926
diff changeset
    52
#include "utilities/stack.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    53
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    54
// A "G1CollectedHeap" is an implementation of a java heap for HotSpot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    55
// It uses the "Garbage First" heap organization and algorithm, which
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    56
// may combine concurrent marking with parallel, incremental compaction of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    57
// heap subsets that will yield large amounts of garbage.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    58
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
    59
// Forward declarations
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    60
class HeapRegion;
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
    61
class HRRSCleanupTask;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    62
class GenerationSpec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    63
class OopsInHeapRegionClosure;
32381
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
    64
class G1ParScanThreadState;
32736
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32735
diff changeset
    65
class G1ParScanThreadStateSet;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
    66
class G1KlassScanClosure;
29701
f638fc81a3d0 8075803: Fix GC includes and forward declarations
stefank
parents: 29693
diff changeset
    67
class G1ParScanThreadState;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    68
class ObjectClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    69
class SpaceClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    70
class CompactibleSpaceClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    71
class Space;
37039
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
    72
class G1CollectionSet;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    73
class G1CollectorPolicy;
37985
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
    74
class G1Policy;
38172
90f405aac699 8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents: 38154
diff changeset
    75
class G1HotCardCache;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    76
class G1RemSet;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    77
class HeapRegionRemSetIterator;
35943
e726308008c0 8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents: 35909
diff changeset
    78
class G1ConcurrentMark;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    79
class ConcurrentMarkThread;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    80
class ConcurrentG1Refine;
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
    81
class GenerationCounters;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    82
class STWGCTimer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    83
class G1NewTracer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    84
class EvacuationFailedInfo;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
    85
class nmethod;
21767
41eaa9a17059 8028128: Add a type safe alternative for working with counter based data
mgronlun
parents: 20318
diff changeset
    86
class Ticks;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 32193
diff changeset
    87
class WorkGang;
32378
8dd0e7359751 8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents: 32360
diff changeset
    88
class G1Allocator;
8dd0e7359751 8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents: 32360
diff changeset
    89
class G1ArchiveAllocator;
35851
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
    90
class G1HeapVerifier;
37144
b7ae74d4d5d8 8151808: Factor G1 heap sizing code out of the G1CollectorPolicy
mgerdin
parents: 37137
diff changeset
    91
class G1HeapSizingPolicy;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    92
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
    93
typedef OverflowTaskQueue<StarTask, mtGC>         RefToScanQueue;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
    94
typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    95
2996
1097030e5ec3 6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents: 2883
diff changeset
    96
typedef int RegionIdx_t;   // needs to hold [ 0..max_regions() )
1097030e5ec3 6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents: 2883
diff changeset
    97
typedef int CardIdx_t;     // needs to hold [ 0..CardsPerRegion )
1097030e5ec3 6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents: 2883
diff changeset
    98
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
    99
// The G1 STW is alive closure.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   100
// An instance is embedded into the G1CH and used as the
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   101
// (optional) _is_alive_non_header closure in the STW
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   102
// reference processor. It is also extensively used during
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   103
// reference processing during STW evacuation pauses.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   104
class G1STWIsAliveClosure: public BoolObjectClosure {
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   105
  G1CollectedHeap* _g1;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   106
public:
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   107
  G1STWIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   108
  bool do_object_b(oop p);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   109
};
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   110
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   111
class RefineCardTableEntryClosure;
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   112
26160
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   113
class G1RegionMappingChangedListener : public G1MappingChangedListener {
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   114
 private:
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   115
  void reset_from_card_cache(uint start_idx, size_t num_regions);
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   116
 public:
27149
9246fc481aa3 8059758: Footprint regressions with JDK-8038423
tschatzl
parents: 27009
diff changeset
   117
  virtual void on_commit(uint start_idx, size_t num_regions, bool zero_filled);
26160
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   118
};
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   119
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30152
diff changeset
   120
class G1CollectedHeap : public CollectedHeap {
39979
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   121
  friend class G1FreeCollectionSetTask;
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   122
  friend class VM_CollectForMetadataAllocation;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   123
  friend class VM_G1CollectForAllocation;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   124
  friend class VM_G1CollectFull;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   125
  friend class VM_G1IncCollectionPause;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   126
  friend class VMStructs;
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   127
  friend class MutatorAllocRegion;
32379
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   128
  friend class G1GCAllocRegion;
35851
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   129
  friend class G1HeapVerifier;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   130
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   131
  // Closures used in implementation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   132
  friend class G1ParScanThreadState;
32736
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32735
diff changeset
   133
  friend class G1ParScanThreadStateSet;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   134
  friend class G1ParTask;
32185
49a57ff2c3cb 8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents: 31976
diff changeset
   135
  friend class G1PLABAllocator;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   136
  friend class G1PrepareCompactClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   137
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   138
  // Other related classes.
27009
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
   139
  friend class HeapRegionClaimer;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   140
28215
4920c0fcdb07 8068036: assert(is_available(index)) failed in G1 cset
tschatzl
parents: 28213
diff changeset
   141
  // Testing classes.
4920c0fcdb07 8068036: assert(is_available(index)) failed in G1 cset
tschatzl
parents: 28213
diff changeset
   142
  friend class G1CheckCSetFastTableClosure;
4920c0fcdb07 8068036: assert(is_available(index)) failed in G1 cset
tschatzl
parents: 28213
diff changeset
   143
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   144
private:
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 32193
diff changeset
   145
  WorkGang* _workers;
37985
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
   146
  G1CollectorPolicy* _collector_policy;
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   147
3697
ea9211aa02f5 6819085: G1: use larger and/or user settable region size
tonyp
parents: 3696
diff changeset
   148
  static size_t _humongous_object_threshold_in_words;
ea9211aa02f5 6819085: G1: use larger and/or user settable region size
tonyp
parents: 3696
diff changeset
   149
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   150
  // The secondary free list which contains regions that have been
26157
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
   151
  // freed up during the cleanup process. This will be appended to
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
   152
  // the master free list when appropriate.
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   153
  FreeRegionList _secondary_free_list;
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   154
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   155
  // It keeps track of the old regions.
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   156
  HeapRegionSet _old_set;
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   157
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   158
  // It keeps track of the humongous regions.
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   159
  HeapRegionSet _humongous_set;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   160
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   161
  void eagerly_reclaim_humongous_regions();
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   162
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   163
  // The number of regions we could create by expansion.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   164
  uint _expansion_regions;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   165
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   166
  // The block offset table for the G1 heap.
35461
1068dcb8d315 8146399: Refactor the BlockOffsetTable classes.
david
parents: 35211
diff changeset
   167
  G1BlockOffsetTable* _bot;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   168
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   169
  // Tears down the region sets / lists so that they are empty and the
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   170
  // regions on the heap do not belong to a region set / list. The
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   171
  // only exception is the humongous set which we leave unaltered. If
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   172
  // free_list_only is true, it will only tear down the master free
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   173
  // list. It is called before a Full GC (free_list_only == false) or
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   174
  // before heap shrinking (free_list_only == true).
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   175
  void tear_down_region_sets(bool free_list_only);
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   176
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   177
  // Rebuilds the region sets / lists so that they are repopulated to
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   178
  // reflect the contents of the heap. The only exception is the
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   179
  // humongous set which was not torn down in the first place. If
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   180
  // free_list_only is true, it will only rebuild the master free
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   181
  // list. It is called after a Full GC (free_list_only == false) or
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   182
  // after heap shrinking (free_list_only == true).
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   183
  void rebuild_region_sets(bool free_list_only);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   184
26160
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   185
  // Callback for region mapping changed events.
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   186
  G1RegionMappingChangedListener _listener;
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
   187
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   188
  // The sequence of all heap regions in the heap.
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
   189
  HeapRegionManager _hrm;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   190
32379
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   191
  // Manages all allocations with regions except humongous object allocations.
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   192
  G1Allocator* _allocator;
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   193
35851
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   194
  // Manages all heap verification.
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   195
  G1HeapVerifier* _verifier;
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   196
31975
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   197
  // Outside of GC pauses, the number of bytes used in all regions other
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   198
  // than the current allocation region(s).
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   199
  size_t _summary_bytes_used;
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   200
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   201
  void increase_used(size_t bytes);
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   202
  void decrease_used(size_t bytes);
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   203
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   204
  void set_used(size_t bytes);
1e8d389159cb 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
ehelin
parents: 31632
diff changeset
   205
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   206
  // Class that handles archive allocation ranges.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   207
  G1ArchiveAllocator* _archive_allocator;
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   208
26841
d460d343d888 8057818: collect allocation context statistics at gc pauses
jcoomes
parents: 26839
diff changeset
   209
  // Statistics for each allocation context
d460d343d888 8057818: collect allocation context statistics at gc pauses
jcoomes
parents: 26839
diff changeset
   210
  AllocationContextStats _allocation_context_stats;
d460d343d888 8057818: collect allocation context statistics at gc pauses
jcoomes
parents: 26839
diff changeset
   211
32379
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   212
  // GC allocation statistics policy for survivors.
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   213
  G1EvacStats _survivor_evac_stats;
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   214
32379
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   215
  // GC allocation statistics policy for tenured objects.
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   216
  G1EvacStats _old_evac_stats;
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   217
11449
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   218
  // It specifies whether we should attempt to expand the heap after a
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   219
  // region allocation failure. If heap expansion fails we set this to
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   220
  // false so that we don't re-attempt the heap expansion (it's likely
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   221
  // that subsequent expansion attempts will also fail if one fails).
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   222
  // Currently, it is only consulted during GC and it's reset at the
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   223
  // start of each GC.
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   224
  bool _expand_heap_after_alloc_failure;
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   225
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   226
  // Helper for monitoring and management support.
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   227
  G1MonitoringSupport* _g1mm;
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   228
30182
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   229
  // Records whether the region at the given index is (still) a
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   230
  // candidate for eager reclaim.  Only valid for humongous start
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   231
  // regions; other regions have unspecified values.  Humongous start
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   232
  // regions are initialized at start of collection pause, with
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   233
  // candidates removed from the set as they are found reachable from
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   234
  // roots or the young generation.
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   235
  class HumongousReclaimCandidates : public G1BiasedMappedArray<bool> {
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   236
   protected:
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   237
    bool default_value() const { return false; }
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   238
   public:
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   239
    void clear() { G1BiasedMappedArray<bool>::clear(); }
30182
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   240
    void set_candidate(uint region, bool value) {
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   241
      set_by_index(region, value);
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   242
    }
30182
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   243
    bool is_candidate(uint region) {
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   244
      return get_by_index(region);
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   245
    }
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   246
  };
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   247
30182
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   248
  HumongousReclaimCandidates _humongous_reclaim_candidates;
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   249
  // Stores whether during humongous object registration we found candidate regions.
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   250
  // If not, we can skip a few steps.
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   251
  bool _has_humongous_reclaim_candidates;
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   252
37989
e0a0f4de45c4 8153170: Card Live Data does not correctly handle eager reclaim
tschatzl
parents: 37985
diff changeset
   253
  volatile uint _gc_time_stamp;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   254
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   255
  G1HRPrinter _hr_printer;
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   256
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   257
  // It decides whether an explicit GC should start a concurrent cycle
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   258
  // instead of doing a STW GC. Currently, a concurrent cycle is
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   259
  // explicitly started if:
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   260
  // (a) cause == _gc_locker and +GCLockerInvokesConcurrent, or
34619
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   261
  // (b) cause == _g1_humongous_allocation
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   262
  // (c) cause == _java_lang_system_gc and +ExplicitGCInvokesConcurrent.
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   263
  // (d) cause == _dcmd_gc_run and +ExplicitGCInvokesConcurrent.
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   264
  // (e) cause == _update_allocation_context_stats_inc
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   265
  // (f) cause == _wb_conc_mark
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   266
  bool should_do_concurrent_full_gc(GCCause::Cause cause);
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   267
31331
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
   268
  // indicates whether we are in young or mixed GC mode
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
   269
  G1CollectorState _collector_state;
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
   270
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   271
  // Keeps track of how many "old marking cycles" (i.e., Full GCs or
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   272
  // concurrent cycles) we have started.
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   273
  volatile uint _old_marking_cycles_started;
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   274
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   275
  // Keeps track of how many "old marking cycles" (i.e., Full GCs or
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   276
  // concurrent cycles) we have completed.
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   277
  volatile uint _old_marking_cycles_completed;
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   278
9334
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   279
  // This is a non-product method that is helpful for testing. It is
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   280
  // called at the end of a GC and artificially expands the heap by
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   281
  // allocating a number of dead regions. This way we can induce very
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   282
  // frequent marking cycles and stress the cleanup / concurrent
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   283
  // cleanup code more (as all the regions that will be allocated by
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   284
  // this method will be found dead by the marking cycle).
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   285
  void allocate_dummy_regions() PRODUCT_RETURN;
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   286
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   287
  // Clear RSets after a compaction. It also resets the GC time stamps.
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   288
  void clear_rsets_post_compaction();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   289
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   290
  // If the HR printer is active, dump the state of the regions in the
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   291
  // heap after a compaction.
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
   292
  void print_hrm_post_compaction();
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   293
30158
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   294
  // Create a memory mapper for auxiliary data structures of the given size and
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   295
  // translation factor.
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   296
  static G1RegionToSpaceMapper* create_aux_memory_mapper(const char* description,
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   297
                                                         size_t size,
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   298
                                                         size_t translation_factor);
bd6094906ef8 8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents: 30154
diff changeset
   299
37985
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
   300
  static G1Policy* create_g1_policy();
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
   301
31344
2316eb7a0358 8025608: GC trace events missing nursery size information
david
parents: 31331
diff changeset
   302
  void trace_heap(GCWhen::Type when, const GCTracer* tracer);
2316eb7a0358 8025608: GC trace events missing nursery size information
david
parents: 31331
diff changeset
   303
34310
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34302
diff changeset
   304
  void process_weak_jni_handles();
32e3c906b613 8139892: Allow G1CollectorPolicy to specify if reference processing should be enabled
ehelin
parents: 34302
diff changeset
   305
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   306
  // These are macros so that, if the assert fires, we get the correct
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   307
  // line number, file, etc.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   308
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   309
#define heap_locking_asserts_params(_extra_message_)                          \
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   310
  "%s : Heap_lock locked: %s, at safepoint: %s, is VM thread: %s",            \
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   311
  (_extra_message_),                                                          \
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   312
  BOOL_TO_STR(Heap_lock->owned_by_self()),                                    \
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   313
  BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()),                       \
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   314
  BOOL_TO_STR(Thread::current()->is_VM_thread())
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   315
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   316
#define assert_heap_locked()                                                  \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   317
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   318
    assert(Heap_lock->owned_by_self(),                                        \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   319
           heap_locking_asserts_params("should be holding the Heap_lock"));   \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   320
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   321
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   322
#define assert_heap_locked_or_at_safepoint(_should_be_vm_thread_)             \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   323
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   324
    assert(Heap_lock->owned_by_self() ||                                      \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   325
           (SafepointSynchronize::is_at_safepoint() &&                        \
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   326
             ((_should_be_vm_thread_) == Thread::current()->is_VM_thread())), \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   327
           heap_locking_asserts_params("should be holding the Heap_lock or "  \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   328
                                        "should be at a safepoint"));         \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   329
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   330
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   331
#define assert_heap_locked_and_not_at_safepoint()                             \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   332
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   333
    assert(Heap_lock->owned_by_self() &&                                      \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   334
                                    !SafepointSynchronize::is_at_safepoint(), \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   335
          heap_locking_asserts_params("should be holding the Heap_lock and "  \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   336
                                       "should not be at a safepoint"));      \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   337
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   338
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   339
#define assert_heap_not_locked()                                              \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   340
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   341
    assert(!Heap_lock->owned_by_self(),                                       \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   342
        heap_locking_asserts_params("should not be holding the Heap_lock"));  \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   343
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   344
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   345
#define assert_heap_not_locked_and_not_at_safepoint()                         \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   346
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   347
    assert(!Heap_lock->owned_by_self() &&                                     \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   348
                                    !SafepointSynchronize::is_at_safepoint(), \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   349
      heap_locking_asserts_params("should not be holding the Heap_lock and "  \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   350
                                   "should not be at a safepoint"));          \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   351
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   352
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   353
#define assert_at_safepoint(_should_be_vm_thread_)                            \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   354
  do {                                                                        \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   355
    assert(SafepointSynchronize::is_at_safepoint() &&                         \
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   356
              ((_should_be_vm_thread_) == Thread::current()->is_VM_thread()), \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   357
           heap_locking_asserts_params("should be at a safepoint"));          \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   358
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   359
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   360
#define assert_not_at_safepoint()                                             \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   361
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   362
    assert(!SafepointSynchronize::is_at_safepoint(),                          \
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32737
diff changeset
   363
           heap_locking_asserts_params("should not be at a safepoint"));      \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   364
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   365
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   366
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   367
10236
c4256e927bed 7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents: 10001
diff changeset
   368
  // The young region list.
38183
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
   369
  G1EdenRegions _eden;
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
   370
  G1SurvivorRegions _survivor;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   371
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   372
  // The current policy object for the collector.
37985
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
   373
  G1Policy* _g1_policy;
37144
b7ae74d4d5d8 8151808: Factor G1 heap sizing code out of the G1CollectorPolicy
mgerdin
parents: 37137
diff changeset
   374
  G1HeapSizingPolicy* _heap_sizing_policy;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   375
37039
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
   376
  G1CollectionSet _collection_set;
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
   377
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   378
  // This is the second level of trying to allocate a new region. If
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   379
  // new_region() didn't find a region on the free_list, this call will
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   380
  // check whether there's anything available on the
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   381
  // secondary_free_list and/or wait for more regions to appear on
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   382
  // that list, if _free_regions_coming is set.
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
   383
  HeapRegion* new_region_try_secondary_free_list(bool is_old);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   384
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   385
  // Try to allocate a single non-humongous HeapRegion sufficient for
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   386
  // an allocation of the given word_size. If do_expand is true,
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   387
  // attempt to expand the heap if necessary to satisfy the allocation
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
   388
  // request. If the region is to be used as an old region or for a
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
   389
  // humongous object, set is_old to true. If not, to false.
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
   390
  HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   391
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   392
  // Initialize a contiguous set of free regions of length num_regions
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   393
  // and starting at index first so that they appear as a single
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   394
  // humongous region.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   395
  HeapWord* humongous_obj_allocate_initialize_regions(uint first,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   396
                                                      uint num_regions,
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   397
                                                      size_t word_size,
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   398
                                                      AllocationContext_t context);
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   399
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   400
  // Attempt to allocate a humongous object of the given size. Return
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   401
  // NULL if unsuccessful.
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   402
  HeapWord* humongous_obj_allocate(size_t word_size, AllocationContext_t context);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   403
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   404
  // The following two methods, allocate_new_tlab() and
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   405
  // mem_allocate(), are the two main entry points from the runtime
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   406
  // into the G1's allocation routines. They have the following
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   407
  // assumptions:
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   408
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   409
  // * They should both be called outside safepoints.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   410
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   411
  // * They should both be called without holding the Heap_lock.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   412
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   413
  // * All allocation requests for new TLABs should go to
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   414
  //   allocate_new_tlab().
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   415
  //
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   416
  // * All non-TLAB allocation requests should go to mem_allocate().
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   417
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   418
  // * If either call cannot satisfy the allocation request using the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   419
  //   current allocating region, they will try to get a new one. If
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   420
  //   this fails, they will attempt to do an evacuation pause and
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   421
  //   retry the allocation.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   422
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   423
  // * If all allocation attempts fail, even after trying to schedule
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   424
  //   an evacuation pause, allocate_new_tlab() will return NULL,
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   425
  //   whereas mem_allocate() will attempt a heap expansion and/or
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   426
  //   schedule a Full GC.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   427
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   428
  // * We do not allow humongous-sized TLABs. So, allocate_new_tlab
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   429
  //   should never be called with word_size being humongous. All
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   430
  //   humongous allocation requests should go to mem_allocate() which
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   431
  //   will satisfy them with a special path.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   432
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   433
  virtual HeapWord* allocate_new_tlab(size_t word_size);
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   434
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   435
  virtual HeapWord* mem_allocate(size_t word_size,
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   436
                                 bool*  gc_overhead_limit_was_exceeded);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   437
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   438
  // The following three methods take a gc_count_before_ret
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   439
  // parameter which is used to return the GC count if the method
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   440
  // returns NULL. Given that we are required to read the GC count
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   441
  // while holding the Heap_lock, and these paths will take the
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   442
  // Heap_lock at some point, it's easier to get them to read the GC
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   443
  // count while holding the Heap_lock before they return NULL instead
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   444
  // of the caller (namely: mem_allocate()) having to also take the
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   445
  // Heap_lock just to read the GC count.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   446
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   447
  // First-level mutator allocation attempt: try to allocate out of
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   448
  // the mutator alloc region without taking the Heap_lock. This
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   449
  // should only be used for non-humongous allocations.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   450
  inline HeapWord* attempt_allocation(size_t word_size,
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   451
                                      uint* gc_count_before_ret,
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   452
                                      uint* gclocker_retry_count_ret);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   453
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   454
  // Second-level mutator allocation attempt: take the Heap_lock and
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   455
  // retry the allocation attempt, potentially scheduling a GC
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   456
  // pause. This should only be used for non-humongous allocations.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   457
  HeapWord* attempt_allocation_slow(size_t word_size,
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   458
                                    AllocationContext_t context,
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   459
                                    uint* gc_count_before_ret,
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   460
                                    uint* gclocker_retry_count_ret);
7905
cc7740616b03 6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents: 7904
diff changeset
   461
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   462
  // Takes the Heap_lock and attempts a humongous allocation. It can
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   463
  // potentially schedule a GC pause.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   464
  HeapWord* attempt_allocation_humongous(size_t word_size,
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   465
                                         uint* gc_count_before_ret,
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   466
                                         uint* gclocker_retry_count_ret);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   467
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   468
  // Allocation attempt that should be called during safepoints (e.g.,
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   469
  // at the end of a successful GC). expect_null_mutator_alloc_region
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   470
  // specifies whether the mutator alloc region is expected to be NULL
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   471
  // or not.
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   472
  HeapWord* attempt_allocation_at_safepoint(size_t word_size,
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   473
                                            AllocationContext_t context,
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   474
                                            bool expect_null_mutator_alloc_region);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   475
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   476
  // These methods are the "callbacks" from the G1AllocRegion class.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   477
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   478
  // For mutator alloc regions.
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   479
  HeapRegion* new_mutator_alloc_region(size_t word_size, bool force);
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   480
  void retire_mutator_alloc_region(HeapRegion* alloc_region,
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   481
                                   size_t allocated_bytes);
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   482
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   483
  // For GC alloc regions.
37159
baf5e8b0bd96 8148759: G1AllocRegion::_count inconsistently used if more than one context is active
brutisso
parents: 37144
diff changeset
   484
  bool has_more_regions(InCSetState dest);
baf5e8b0bd96 8148759: G1AllocRegion::_count inconsistently used if more than one context is active
brutisso
parents: 37144
diff changeset
   485
  HeapRegion* new_gc_alloc_region(size_t word_size, InCSetState dest);
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   486
  void retire_gc_alloc_region(HeapRegion* alloc_region,
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   487
                              size_t allocated_bytes, InCSetState dest);
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   488
34241
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   489
  // - if explicit_gc is true, the GC is for a System.gc() etc,
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   490
  //   otherwise it's for a failed allocation.
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   491
  // - if clear_all_soft_refs is true, all soft references should be
34241
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   492
  //   cleared during the GC.
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   493
  // - it returns false if it is unable to do the collection due to the
34241
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   494
  //   GC locker being active, true otherwise.
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   495
  bool do_full_collection(bool explicit_gc,
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   496
                          bool clear_all_soft_refs);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   497
34241
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   498
  // Callback from VM_G1CollectFull operation, or collect_as_vm_thread.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   499
  virtual void do_full_collection(bool clear_all_soft_refs);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   500
34241
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   501
  // Resize the heap if necessary after a full collection.
78486dc87f38 8143252: Clean up G1CollectedHeap interface
drwhite
parents: 33789
diff changeset
   502
  void resize_if_necessary_after_full_collection();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   503
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   504
  // Callback from VM_G1CollectForAllocation operation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   505
  // This function does everything necessary/possible to satisfy a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   506
  // failed allocation request (including collection, expansion, etc.)
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   507
  HeapWord* satisfy_failed_allocation(size_t word_size,
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   508
                                      AllocationContext_t context,
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   509
                                      bool* succeeded);
33108
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   510
private:
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   511
  // Helper method for satisfy_failed_allocation()
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   512
  HeapWord* satisfy_failed_allocation_helper(size_t word_size,
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   513
                                             AllocationContext_t context,
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   514
                                             bool do_gc,
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   515
                                             bool clear_all_soft_refs,
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   516
                                             bool expect_null_mutator_alloc_region,
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   517
                                             bool* gc_succeeded);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   518
33108
6714a3872d8f 8130265: gctests/LargeObjects/large001 fails with OutOfMemoryError: Java heap space
aharlap
parents: 33105
diff changeset
   519
protected:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   520
  // Attempting to expand the heap sufficiently
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   521
  // to support an allocation of the given "word_size".  If
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   522
  // successful, perform the allocation and return the address of the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   523
  // allocated block, or else "NULL".
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   524
  HeapWord* expand_and_allocate(size_t word_size, AllocationContext_t context);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   525
36367
313c87c050f7 8076463: Add logging for the preserve CM referents task
tschatzl
parents: 35943
diff changeset
   526
  // Preserve any referents discovered by concurrent marking that have not yet been
313c87c050f7 8076463: Add logging for the preserve CM referents task
tschatzl
parents: 35943
diff changeset
   527
  // copied by the STW pause.
313c87c050f7 8076463: Add logging for the preserve CM referents task
tschatzl
parents: 35943
diff changeset
   528
  void preserve_cm_referents(G1ParScanThreadStateSet* per_thread_states);
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   529
  // Process any reference objects discovered during
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   530
  // an incremental evacuation pause.
32736
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32735
diff changeset
   531
  void process_discovered_references(G1ParScanThreadStateSet* per_thread_states);
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   532
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   533
  // Enqueue any remaining discovered references
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   534
  // after processing.
32736
755024a84282 8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents: 32735
diff changeset
   535
  void enqueue_discovered_references(G1ParScanThreadStateSet* per_thread_states);
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   536
36368
569d6e8072a9 8150630: Add logging for ParScanThreadState merge phase
tschatzl
parents: 36367
diff changeset
   537
  // Merges the information gathered on a per-thread basis for all worker threads
569d6e8072a9 8150630: Add logging for ParScanThreadState merge phase
tschatzl
parents: 36367
diff changeset
   538
  // during GC into global variables.
569d6e8072a9 8150630: Add logging for ParScanThreadState merge phase
tschatzl
parents: 36367
diff changeset
   539
  void merge_per_thread_state_info(G1ParScanThreadStateSet* per_thread_states);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   540
public:
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 32193
diff changeset
   541
  WorkGang* workers() const { return _workers; }
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   542
26839
021bfc544c6f 8057658: Enable G1 FullGC extensions
sjohanss
parents: 26837
diff changeset
   543
  G1Allocator* allocator() {
021bfc544c6f 8057658: Enable G1 FullGC extensions
sjohanss
parents: 26837
diff changeset
   544
    return _allocator;
021bfc544c6f 8057658: Enable G1 FullGC extensions
sjohanss
parents: 26837
diff changeset
   545
  }
021bfc544c6f 8057658: Enable G1 FullGC extensions
sjohanss
parents: 26837
diff changeset
   546
35851
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   547
  G1HeapVerifier* verifier() {
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   548
    return _verifier;
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   549
  }
5451ff646f8e 8147814: Move verification code out of g1collectedheap
david
parents: 35461
diff changeset
   550
10671
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   551
  G1MonitoringSupport* g1mm() {
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   552
    assert(_g1mm != NULL, "should have been initialized");
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   553
    return _g1mm;
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   554
  }
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   555
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   556
  // Expand the garbage-first heap by at least the given size (in bytes!).
8103
65eafe3fb3c7 6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents: 8072
diff changeset
   557
  // Returns true if the heap was expanded by the requested amount;
65eafe3fb3c7 6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents: 8072
diff changeset
   558
  // false otherwise.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   559
  // (Rounds up to a HeapRegion boundary.)
33577
d6c1611973dc 8060017: G1: Report heap sizing time
ecaspole
parents: 33212
diff changeset
   560
  bool expand(size_t expand_bytes, double* expand_time_ms = NULL);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   561
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   562
  // Returns the PLAB statistics for a given destination.
32379
aa14adafaf0f 8073013: Add detailed information about PLAB memory usage
tschatzl
parents: 32378
diff changeset
   563
  inline G1EvacStats* alloc_buffer_stats(InCSetState dest);
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   564
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   565
  // Determines PLAB size for a given destination.
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   566
  inline size_t desired_plab_sz(InCSetState dest);
26837
72a43d3841e7 8057536: Refactor G1 to allow context specific allocations
sjohanss
parents: 26422
diff changeset
   567
26841
d460d343d888 8057818: collect allocation context statistics at gc pauses
jcoomes
parents: 26839
diff changeset
   568
  inline AllocationContextStats& allocation_context_stats();
d460d343d888 8057818: collect allocation context statistics at gc pauses
jcoomes
parents: 26839
diff changeset
   569
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   570
  // Do anything common to GC's.
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   571
  void gc_prologue(bool full);
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   572
  void gc_epilogue(bool full);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   573
30182
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   574
  // Modify the reclaim candidate set and test for presence.
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   575
  // These are only valid for starts_humongous regions.
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   576
  inline void set_humongous_reclaim_candidate(uint region, bool value);
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   577
  inline bool is_humongous_reclaim_candidate(uint region);
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   578
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   579
  // Remove from the reclaim candidate set.  Also remove from the
1c980a880941 8069367: Eagerly reclaimed humongous objects left on mark stack
kbarrett
parents: 30171
diff changeset
   580
  // collection set so that later encounters avoid the slow path.
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   581
  inline void set_humongous_is_live(oop obj);
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   582
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   583
  // Register the given region to be part of the collection set.
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   584
  inline void register_humongous_region_with_cset(uint index);
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   585
  // Register regions with humongous objects (actually on the start region) in
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
   586
  // the in_cset_fast_test table.
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   587
  void register_humongous_regions_with_cset();
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   588
  // We register a region with the fast "in collection set" test. We
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   589
  // simply set to true the array slot corresponding to this region.
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   590
  void register_young_region_with_cset(HeapRegion* r) {
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   591
    _in_cset_fast_test.set_in_young(r->hrm_index());
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   592
  }
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   593
  void register_old_region_with_cset(HeapRegion* r) {
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
   594
    _in_cset_fast_test.set_in_old(r->hrm_index());
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   595
  }
35051
002d874a4284 8144714: Add extension point to G1 evacuation closures
mgerdin
parents: 34619
diff changeset
   596
  inline void register_ext_region_with_cset(HeapRegion* r) {
002d874a4284 8144714: Add extension point to G1 evacuation closures
mgerdin
parents: 34619
diff changeset
   597
    _in_cset_fast_test.set_ext(r->hrm_index());
002d874a4284 8144714: Add extension point to G1 evacuation closures
mgerdin
parents: 34619
diff changeset
   598
  }
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   599
  void clear_in_cset(const HeapRegion* hr) {
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   600
    _in_cset_fast_test.clear(hr);
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
   601
  }
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   602
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   603
  void clear_cset_fast_test() {
24100
7e71ac14ec06 8027553: Change the in_cset_fast_test functionality to use the G1BiasedArray abstraction
tschatzl
parents: 24093
diff changeset
   604
    _in_cset_fast_test.clear();
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   605
  }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   606
34619
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   607
  bool is_user_requested_concurrent_full_gc(GCCause::Cause cause);
83b1fedf01e9 8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents: 34311
diff changeset
   608
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   609
  // This is called at the start of either a concurrent cycle or a Full
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   610
  // GC to update the number of old marking cycles started.
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   611
  void increment_old_marking_cycles_started();
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   612
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   613
  // This is called at the end of either a concurrent cycle or a Full
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   614
  // GC to update the number of old marking cycles completed. Those two
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   615
  // can happen in a nested fashion, i.e., we start a concurrent
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   616
  // cycle, a Full GC happens half-way through it which ends first,
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   617
  // and then the cycle notices that a Full GC happened and ends
7455
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   618
  // too. The concurrent parameter is a boolean to help us do a bit
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   619
  // tighter consistency checking in the method. If concurrent is
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   620
  // false, the caller is the inner caller in the nesting (i.e., the
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   621
  // Full GC). If concurrent is true, the caller is the outer caller
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   622
  // in this nesting (i.e., the concurrent cycle). Further nesting is
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   623
  // not currently supported. The end of this call also notifies
7455
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   624
  // the FullGCCount_lock in case a Java thread is waiting for a full
22e19e8c0beb 7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents: 7416
diff changeset
   625
  // GC to happen (e.g., it called System.gc() with
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   626
  // +ExplicitGCInvokesConcurrent).
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   627
  void increment_old_marking_cycles_completed(bool concurrent);
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   628
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   629
  uint old_marking_cycles_completed() {
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   630
    return _old_marking_cycles_completed;
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   631
  }
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   632
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   633
  G1HRPrinter* hr_printer() { return &_hr_printer; }
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   634
32185
49a57ff2c3cb 8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents: 31976
diff changeset
   635
  // Allocates a new heap region instance.
49a57ff2c3cb 8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents: 31976
diff changeset
   636
  HeapRegion* new_heap_region(uint hrs_index, MemRegion mr);
49a57ff2c3cb 8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents: 31976
diff changeset
   637
32193
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   638
  // Allocate the highest free region in the reserved heap. This will commit
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   639
  // regions as necessary.
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   640
  HeapRegion* alloc_highest_free_region();
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   641
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   642
  // Frees a non-humongous region by initializing its contents and
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   643
  // adding it to the free list that's passed as a parameter (this is
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   644
  // usually a local list which will be appended to the master free
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   645
  // list later). The used bytes of freed regions are accumulated in
39979
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   646
  // pre_used. If skip_remset is true, the region's RSet will not be freed
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   647
  // up. If skip_hot_card_cache is true, the region's hot card cache will not
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   648
  // be freed up. The assumption is that this will be done later.
23453
09cfb0164acf 8027295: Free CSet takes ~50% of young pause time
tschatzl
parents: 23451
diff changeset
   649
  // The locked parameter indicates if the caller has already taken
09cfb0164acf 8027295: Free CSet takes ~50% of young pause time
tschatzl
parents: 23451
diff changeset
   650
  // care of proper synchronization. This may allow some optimizations.
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   651
  void free_region(HeapRegion* hr,
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   652
                   FreeRegionList* free_list,
39979
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   653
                   bool skip_remset,
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   654
                   bool skip_hot_card_cache = false,
23453
09cfb0164acf 8027295: Free CSet takes ~50% of young pause time
tschatzl
parents: 23451
diff changeset
   655
                   bool locked = false);
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   656
32193
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   657
  // It dirties the cards that cover the block so that the post
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   658
  // write barrier never queues anything when updating objects on this
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   659
  // block. It is assumed (and in fact we assert) that the block
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   660
  // belongs to a young region.
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   661
  inline void dirty_young_block(HeapWord* start, size_t word_size);
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
   662
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   663
  // Frees a humongous region by collapsing it into individual regions
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   664
  // and calling free_region() for each of them. The freed regions
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   665
  // will be added to the free list that's passed as a parameter (this
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   666
  // is usually a local list which will be appended to the master free
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   667
  // list later). The used bytes of freed regions are accumulated in
39979
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   668
  // pre_used. If skip_remset is true, the region's RSet will not be freed
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   669
  // up. The assumption is that this will be done later.
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   670
  void free_humongous_region(HeapRegion* hr,
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
   671
                             FreeRegionList* free_list,
39979
b17e445924da 8034842: Parallelize the Free CSet phase in G1
tschatzl
parents: 39698
diff changeset
   672
                             bool skip_remset);
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   673
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   674
  // Facility for allocating in 'archive' regions in high heap memory and
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   675
  // recording the allocated ranges. These should all be called from the
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   676
  // VM thread at safepoints, without the heap lock held. They can be used
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   677
  // to create and archive a set of heap regions which can be mapped at the
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   678
  // same fixed addresses in a subsequent JVM invocation.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   679
  void begin_archive_alloc_range();
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   680
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   681
  // Check if the requested size would be too large for an archive allocation.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   682
  bool is_archive_alloc_too_large(size_t word_size);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   683
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   684
  // Allocate memory of the requested size from the archive region. This will
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   685
  // return NULL if the size is too large or if no memory is available. It
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   686
  // does not trigger a garbage collection.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   687
  HeapWord* archive_mem_allocate(size_t word_size);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   688
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   689
  // Optionally aligns the end address and returns the allocated ranges in
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   690
  // an array of MemRegions in order of ascending addresses.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   691
  void end_archive_alloc_range(GrowableArray<MemRegion>* ranges,
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   692
                               size_t end_alignment_in_bytes = 0);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   693
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   694
  // Facility for allocating a fixed range within the heap and marking
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   695
  // the containing regions as 'archive'. For use at JVM init time, when the
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   696
  // caller may mmap archived heap data at the specified range(s).
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   697
  // Verify that the MemRegions specified in the argument array are within the
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   698
  // reserved heap.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   699
  bool check_archive_addresses(MemRegion* range, size_t count);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   700
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   701
  // Commit the appropriate G1 regions containing the specified MemRegions
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   702
  // and mark them as 'archive' regions. The regions in the array must be
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   703
  // non-overlapping and in order of ascending address.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   704
  bool alloc_archive_regions(MemRegion* range, size_t count);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   705
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   706
  // Insert any required filler objects in the G1 regions around the specified
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   707
  // ranges to make the regions parseable. This must be called after
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   708
  // alloc_archive_regions, and after class loading has occurred.
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   709
  void fill_archive_regions(MemRegion* range, size_t count);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
   710
32589
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   711
  // For each of the specified MemRegions, uncommit the containing G1 regions
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   712
  // which had been allocated by alloc_archive_regions. This should be called
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   713
  // rather than fill_archive_regions at JVM init time if the archive file
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   714
  // mapping failed, with the same non-overlapping and sorted MemRegion array.
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   715
  void dealloc_archive_regions(MemRegion* range, size_t count);
f86fb16fcab0 8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents: 32381
diff changeset
   716
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   717
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   718
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   719
  // Shrink the garbage-first heap by at most the given size (in bytes!).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   720
  // (Rounds down to a HeapRegion boundary.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   721
  virtual void shrink(size_t expand_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   722
  void shrink_helper(size_t expand_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   723
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   724
  #if TASKQUEUE_STATS
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   725
  static void print_taskqueue_stats_hdr(outputStream* const st);
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   726
  void print_taskqueue_stats() const;
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   727
  void reset_taskqueue_stats();
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   728
  #endif // TASKQUEUE_STATS
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   729
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   730
  // Schedule the VM operation that will do an evacuation pause to
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   731
  // satisfy an allocation request of word_size. *succeeded will
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   732
  // return whether the VM operation was successful (it did do an
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   733
  // evacuation pause) or not (another thread beat us to it or the GC
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   734
  // locker was active). Given that we should not be holding the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   735
  // Heap_lock when we enter this method, we will pass the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   736
  // gc_count_before (i.e., total_collections()) as a parameter since
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   737
  // it has to be read while holding the Heap_lock. Currently, both
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   738
  // methods that call do_collection_pause() release the Heap_lock
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   739
  // before the call, so it's easy to read gc_count_before just before.
19549
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   740
  HeapWord* do_collection_pause(size_t         word_size,
29078
3b7dd035c20b 8072621: Clean up around VM_GC_Operations
mlarsson
parents: 28478
diff changeset
   741
                                uint           gc_count_before,
19549
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   742
                                bool*          succeeded,
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   743
                                GCCause::Cause gc_cause);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   744
31397
c9cc3289b80c 8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents: 31346
diff changeset
   745
  void wait_for_root_region_scanning();
c9cc3289b80c 8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents: 31346
diff changeset
   746
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   747
  // The guts of the incremental collection pause, executed by the vm
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   748
  // thread. It returns false if it is unable to do the collection due
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   749
  // to the GC locker being active, true otherwise
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   750
  bool do_collection_pause_at_safepoint(double target_pause_time_ms);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   751
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   752
  // Actually do the work of evacuating the collection set.
33609
299b060a610d 8139149: Split G1 evacuate_collection_set into multiple steps
mgerdin
parents: 33577
diff changeset
   753
  virtual void evacuate_collection_set(EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* per_thread_states);
299b060a610d 8139149: Split G1 evacuate_collection_set into multiple steps
mgerdin
parents: 33577
diff changeset
   754
299b060a610d 8139149: Split G1 evacuate_collection_set into multiple steps
mgerdin
parents: 33577
diff changeset
   755
  void pre_evacuate_collection_set();
299b060a610d 8139149: Split G1 evacuate_collection_set into multiple steps
mgerdin
parents: 33577
diff changeset
   756
  void post_evacuate_collection_set(EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* pss);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   757
32381
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   758
  // Print the header for the per-thread termination statistics.
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   759
  static void print_termination_stats_hdr();
32381
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   760
  // Print actual per-thread termination statistics.
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   761
  void print_termination_stats(uint worker_id,
32381
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   762
                               double elapsed_ms,
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   763
                               double strong_roots_ms,
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   764
                               double term_ms,
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   765
                               size_t term_attempts,
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   766
                               size_t alloc_buffer_waste,
b750fd963056 8040162: Avoid reallocating PLABs between GC phases in G1
tschatzl
parents: 32380
diff changeset
   767
                               size_t undo_waste) const;
32380
1dcdb686f0cb 8133530: Add JFR event for evacuation statistics
tschatzl
parents: 32379
diff changeset
   768
  // Update object copying statistics.
1dcdb686f0cb 8133530: Add JFR event for evacuation statistics
tschatzl
parents: 32379
diff changeset
   769
  void record_obj_copy_mem_stats();
1dcdb686f0cb 8133530: Add JFR event for evacuation statistics
tschatzl
parents: 32379
diff changeset
   770
38172
90f405aac699 8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents: 38154
diff changeset
   771
  // The hot card cache for remembered set insertion optimization.
90f405aac699 8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents: 38154
diff changeset
   772
  G1HotCardCache* _hot_card_cache;
90f405aac699 8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents: 38154
diff changeset
   773
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   774
  // The g1 remembered set of the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   775
  G1RemSet* _g1_rem_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   776
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   777
  // A set of cards that cover the objects for which the Rsets should be updated
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   778
  // concurrently after the collection.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   779
  DirtyCardQueueSet _dirty_card_queue_set;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   780
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   781
  // The closure used to refine a single card.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   782
  RefineCardTableEntryClosure* _refine_cte_cl;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   783
39698
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
   784
  // After a collection pause, convert the regions in the collection set into free
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   785
  // regions.
39698
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
   786
  void free_collection_set(G1CollectionSet* collection_set, EvacuationInfo& evacuation_info, const size_t* surviving_young_words);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   787
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   788
  // Abandon the current collection set without recording policy
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   789
  // statistics or updating free lists.
39698
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
   790
  void abandon_collection_set(G1CollectionSet* collection_set);
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   791
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   792
  // The concurrent marker (and the thread it runs in.)
35943
e726308008c0 8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents: 35909
diff changeset
   793
  G1ConcurrentMark* _cm;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   794
  ConcurrentMarkThread* _cmThread;
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
  // The concurrent refiner.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   797
  ConcurrentG1Refine* _cg1r;
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
  // The parallel task queues
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   800
  RefToScanQueueSet *_task_queues;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   801
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   802
  // True iff a evacuation has failed in the current collection.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   803
  bool _evacuation_failed;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   804
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   805
  EvacuationFailedInfo* _evacuation_failed_info_array;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   806
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   807
  // Failed evacuations cause some logical from-space objects to have
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   808
  // forwarding pointers to themselves.  Reset them.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   809
  void remove_self_forwarding_pointers();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   810
34311
586e90e84d60 8142404: Parallelize the restoring of preserved marks
ehelin
parents: 34310
diff changeset
   811
  // Restore the objects in the regions in the collection set after an
586e90e84d60 8142404: Parallelize the restoring of preserved marks
ehelin
parents: 34310
diff changeset
   812
  // evacuation failure.
586e90e84d60 8142404: Parallelize the restoring of preserved marks
ehelin
parents: 34310
diff changeset
   813
  void restore_after_evac_failure();
31976
da45f85bf4e1 8004687: G1: Parallelize object self-forwarding and scanning during an evacuation failure
tschatzl
parents: 31975
diff changeset
   814
38081
a3bcb7197d45 8151556: Use the PreservedMarks* classes for the G1 preserved mark stacks
tonyp
parents: 37989
diff changeset
   815
  PreservedMarksSet _preserved_marks_set;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   816
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   817
  // Preserve the mark of "obj", if necessary, in preparation for its mark
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   818
  // word being overwritten with a self-forwarding-pointer.
32187
0891f3fa84fc 8133047: Rename G1ParScanThreadState::_queue_num to _worker_id
tschatzl
parents: 32185
diff changeset
   819
  void preserve_mark_during_evac_failure(uint worker_id, oop obj, markOop m);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   820
13517
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   821
#ifndef PRODUCT
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   822
  // Support for forcing evacuation failures. Analogous to
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   823
  // PromotionFailureALot for the other collectors.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   824
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   825
  // Records whether G1EvacuationFailureALot should be in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   826
  // for the current GC
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   827
  bool _evacuation_failure_alot_for_current_gc;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   828
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   829
  // Used to record the GC number for interval checking when
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   830
  // determining whether G1EvaucationFailureALot is in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   831
  // for the current GC.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   832
  size_t _evacuation_failure_alot_gc_number;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   833
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   834
  // Count of the number of evacuations between failures.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   835
  volatile size_t _evacuation_failure_alot_count;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   836
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   837
  // Set whether G1EvacuationFailureALot should be in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   838
  // for the current GC (based upon the type of GC and which
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   839
  // command line flags are set);
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   840
  inline bool evacuation_failure_alot_for_gc_type(bool gcs_are_young,
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   841
                                                  bool during_initial_mark,
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   842
                                                  bool during_marking);
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   843
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   844
  inline void set_evacuation_failure_alot_for_current_gc();
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   845
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   846
  // Return true if it's time to cause an evacuation failure.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   847
  inline bool evacuation_should_fail();
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   848
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   849
  // Reset the G1EvacuationFailureALot counters.  Should be called at
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   850
  // the end of an evacuation pause in which an evacuation failure occurred.
13517
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   851
  inline void reset_evacuation_should_fail();
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   852
#endif // !PRODUCT
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   853
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   854
  // ("Weak") Reference processing support.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   855
  //
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   856
  // G1 has 2 instances of the reference processor class. One
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   857
  // (_ref_processor_cm) handles reference object discovery
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   858
  // and subsequent processing during concurrent marking cycles.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   859
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   860
  // The other (_ref_processor_stw) handles reference object
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   861
  // discovery and processing during full GCs and incremental
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   862
  // evacuation pauses.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   863
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   864
  // During an incremental pause, reference discovery will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   865
  // temporarily disabled for _ref_processor_cm and will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   866
  // enabled for _ref_processor_stw. At the end of the evacuation
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   867
  // pause references discovered by _ref_processor_stw will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   868
  // processed and discovery will be disabled. The previous
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   869
  // setting for reference object discovery for _ref_processor_cm
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   870
  // will be re-instated.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   871
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   872
  // At the start of marking:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   873
  //  * Discovery by the CM ref processor is verified to be inactive
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   874
  //    and it's discovered lists are empty.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   875
  //  * Discovery by the CM ref processor is then enabled.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   876
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   877
  // At the end of marking:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   878
  //  * Any references on the CM ref processor's discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   879
  //    lists are processed (possibly MT).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   880
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   881
  // At the start of full GC we:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   882
  //  * Disable discovery by the CM ref processor and
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   883
  //    empty CM ref processor's discovered lists
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   884
  //    (without processing any entries).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   885
  //  * Verify that the STW ref processor is inactive and it's
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   886
  //    discovered lists are empty.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   887
  //  * Temporarily set STW ref processor discovery as single threaded.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   888
  //  * Temporarily clear the STW ref processor's _is_alive_non_header
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   889
  //    field.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   890
  //  * Finally enable discovery by the STW ref processor.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   891
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   892
  // The STW ref processor is used to record any discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   893
  // references during the full GC.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   894
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   895
  // At the end of a full GC we:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   896
  //  * Enqueue any reference objects discovered by the STW ref processor
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   897
  //    that have non-live referents. This has the side-effect of
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   898
  //    making the STW ref processor inactive by disabling discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   899
  //  * Verify that the CM ref processor is still inactive
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   900
  //    and no references have been placed on it's discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   901
  //    lists (also checked as a precondition during initial marking).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   902
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   903
  // The (stw) reference processor...
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   904
  ReferenceProcessor* _ref_processor_stw;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   905
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   906
  STWGCTimer* _gc_timer_stw;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   907
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   908
  G1NewTracer* _gc_tracer_stw;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   909
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   910
  // During reference object discovery, the _is_alive_non_header
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   911
  // closure (if non-null) is applied to the referent object to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   912
  // determine whether the referent is live. If so then the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   913
  // reference object does not need to be 'discovered' and can
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   914
  // be treated as a regular oop. This has the benefit of reducing
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   915
  // the number of 'discovered' reference objects that need to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   916
  // be processed.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   917
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   918
  // Instance of the is_alive closure for embedding into the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   919
  // STW reference processor as the _is_alive_non_header field.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   920
  // Supplying a value for the _is_alive_non_header field is
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   921
  // optional but doing so prevents unnecessary additions to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   922
  // the discovered lists during reference discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   923
  G1STWIsAliveClosure _is_alive_closure_stw;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   924
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   925
  // The (concurrent marking) reference processor...
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   926
  ReferenceProcessor* _ref_processor_cm;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   927
7657
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7455
diff changeset
   928
  // Instance of the concurrent mark is_alive closure for embedding
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   929
  // into the Concurrent Marking reference processor as the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   930
  // _is_alive_non_header field. Supplying a value for the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   931
  // _is_alive_non_header field is optional but doing so prevents
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   932
  // unnecessary additions to the discovered lists during reference
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   933
  // discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   934
  G1CMIsAliveClosure _is_alive_closure_cm;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   935
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   936
  volatile bool _free_regions_coming;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   937
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   938
public:
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6260
diff changeset
   939
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   940
  void set_refine_cte_cl_concurrency(bool concurrent);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   941
30585
12f312d694cd 6407976: GC worker number should be unsigned
eistepan
parents: 30571
diff changeset
   942
  RefToScanQueue *task_queue(uint i) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   943
30878
f1702744b3a4 8080877: Don't use workers()->total_workers() when walking G1CollectedHeap::_task_queues
stefank
parents: 30875
diff changeset
   944
  uint num_task_queues() const;
f1702744b3a4 8080877: Don't use workers()->total_workers() when walking G1CollectedHeap::_task_queues
stefank
parents: 30875
diff changeset
   945
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   946
  // A set of cards where updates happened during the GC
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   947
  DirtyCardQueueSet& dirty_card_queue_set() { return _dirty_card_queue_set; }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   948
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   949
  // Create a G1CollectedHeap with the specified policy.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   950
  // Must call the initialize method afterwards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   951
  // May not return if something goes wrong.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   952
  G1CollectedHeap(G1CollectorPolicy* policy);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   953
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   954
  // Initialize the G1CollectedHeap to have the initial and
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   955
  // maximum sizes and remembered and barrier sets
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   956
  // specified by the policy object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   957
  jint initialize();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   958
24093
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 23855
diff changeset
   959
  virtual void stop();
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 23855
diff changeset
   960
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19549
diff changeset
   961
  // Return the (conservative) maximum heap alignment for any G1 heap
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19549
diff changeset
   962
  static size_t conservative_max_heap_alignment();
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19549
diff changeset
   963
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   964
  // Does operations required after initialization has been done.
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   965
  void post_initialize();
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   966
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   967
  // Initialize weak reference processing.
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   968
  void ref_processing_init();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   969
29808
9bbc65318fdd 8076294: Cleanup of CollectedHeap::kind()
pliden
parents: 29803
diff changeset
   970
  virtual Name kind() const {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   971
    return CollectedHeap::G1CollectedHeap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   972
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   973
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   974
  virtual const char* name() const {
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   975
    return "G1";
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   976
  }
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
   977
33130
a776072941e8 8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents: 33108
diff changeset
   978
  const G1CollectorState* collector_state() const { return &_collector_state; }
31331
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
   979
  G1CollectorState* collector_state() { return &_collector_state; }
a7c714b6cfb3 7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents: 31032
diff changeset
   980
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   981
  // The current policy object for the collector.
37985
539c597ee0fa 8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents: 37414
diff changeset
   982
  G1Policy* g1_policy() const { return _g1_policy; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   983
37039
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
   984
  const G1CollectionSet* collection_set() const { return &_collection_set; }
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
   985
  G1CollectionSet* collection_set() { return &_collection_set; }
79f62b89a7a6 8151178: Move the collection set out of the G1 collector policy
mgerdin
parents: 36370
diff changeset
   986
32735
c6063d028c3c 8134797: Remove explicit casts in CollectorPolicy hierarchy
kbarrett
parents: 32589
diff changeset
   987
  virtual CollectorPolicy* collector_policy() const;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   988
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   989
  // Adaptive size policy.  No such thing for g1.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   990
  virtual AdaptiveSizePolicy* size_policy() { return NULL; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   991
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   992
  // The rem set and barrier set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   993
  G1RemSet* g1_rem_set() const { return _g1_rem_set; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   994
37414
2672ba9af0dc 8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents: 37159
diff changeset
   995
  // Try to minimize the remembered set.
2672ba9af0dc 8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents: 37159
diff changeset
   996
  void scrub_rem_set();
35211
3771329165d4 8145774: Move scrubbing setup code away out of ConcurrentMark
tschatzl
parents: 35163
diff changeset
   997
37989
e0a0f4de45c4 8153170: Card Live Data does not correctly handle eager reclaim
tschatzl
parents: 37985
diff changeset
   998
  uint get_gc_time_stamp() {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   999
    return _gc_time_stamp;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1000
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1001
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 24244
diff changeset
  1002
  inline void reset_gc_time_stamp();
1385
1751733b089b 6723570: G1: assertion failure: p == current_top or oop(p)->is_oop(),"p is not a block start" (revisited!)
iveresov
parents: 1374
diff changeset
  1003
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1004
  void check_gc_time_stamps() PRODUCT_RETURN;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1005
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 24244
diff changeset
  1006
  inline void increment_gc_time_stamp();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1007
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1008
  // Reset the given region's GC timestamp. If it's starts humongous,
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1009
  // also reset the GC timestamp of its corresponding
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1010
  // continues humongous regions too.
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1011
  void reset_gc_time_stamps(HeapRegion* hr);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1012
33204
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33203
diff changeset
  1013
  // Apply the given closure on all cards in the Hot Card Cache, emptying it.
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33203
diff changeset
  1014
  void iterate_hcc_closure(CardTableEntryClosure* cl, uint worker_i);
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33203
diff changeset
  1015
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33203
diff changeset
  1016
  // Apply the given closure on all cards in the Dirty Card Queue Set, emptying it.
b8a3901ac5b3 8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents: 33203
diff changeset
  1017
  void iterate_dirty_card_closure(CardTableEntryClosure* cl, uint worker_i);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1018
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1019
  // The shared block offset table array.
35461
1068dcb8d315 8146399: Refactor the BlockOffsetTable classes.
david
parents: 35211
diff changeset
  1020
  G1BlockOffsetTable* bot() const { return _bot; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1021
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1022
  // Reference Processing accessors
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1023
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1024
  // The STW reference processor....
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1025
  ReferenceProcessor* ref_processor_stw() const { return _ref_processor_stw; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1026
31619
f27b8fcf4018 8078901: Add trace event for G1 MMU information
sjohanss
parents: 31397
diff changeset
  1027
  G1NewTracer* gc_tracer_stw() const { return _gc_tracer_stw; }
f27b8fcf4018 8078901: Add trace event for G1 MMU information
sjohanss
parents: 31397
diff changeset
  1028
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1029
  // The Concurrent Marking reference processor...
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1030
  ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1031
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1032
  virtual size_t capacity() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1033
  virtual size_t used() const;
3263
23d2d46c6d08 6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents: 3262
diff changeset
  1034
  // This should be called when we're not holding the heap lock. The
23d2d46c6d08 6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents: 3262
diff changeset
  1035
  // result might be a bit inaccurate.
23d2d46c6d08 6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents: 3262
diff changeset
  1036
  size_t used_unlocked() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1037
  size_t recalculate_used() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1038
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1039
  // These virtual functions do the actual allocation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1040
  // Some heaps may offer a contiguous region for shared non-blocking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1041
  // allocation, via inlined code (by exporting the address of the top and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1042
  // end fields defining the extent of the contiguous allocation region.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1043
  // But G1CollectedHeap doesn't yet support this.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1044
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1045
  virtual bool is_maximal_no_gc() const {
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1046
    return _hrm.available() == 0;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1047
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1048
26157
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
  1049
  // The current number of regions in the heap.
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1050
  uint num_regions() const { return _hrm.length(); }
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1051
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1052
  // The max number of regions in the heap.
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1053
  uint max_regions() const { return _hrm.max_length(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1054
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1055
  // The number of regions that are completely free.
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1056
  uint num_free_regions() const { return _hrm.num_free_regions(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1057
29685
c19484601161 8061715: gc/g1/TestShrinkAuxiliaryData15.java fails with java.lang.RuntimeException: heap decommit failed - after > before
azakharov
parents: 29470
diff changeset
  1058
  MemoryUsage get_auxiliary_data_memory_usage() const {
c19484601161 8061715: gc/g1/TestShrinkAuxiliaryData15.java fails with java.lang.RuntimeException: heap decommit failed - after > before
azakharov
parents: 29470
diff changeset
  1059
    return _hrm.get_auxiliary_data_memory_usage();
c19484601161 8061715: gc/g1/TestShrinkAuxiliaryData15.java fails with java.lang.RuntimeException: heap decommit failed - after > before
azakharov
parents: 29470
diff changeset
  1060
  }
c19484601161 8061715: gc/g1/TestShrinkAuxiliaryData15.java fails with java.lang.RuntimeException: heap decommit failed - after > before
azakharov
parents: 29470
diff changeset
  1061
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1062
  // The number of regions that are not completely free.
26157
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
  1063
  uint num_used_regions() const { return num_regions() - num_free_regions(); }
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1064
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1065
#ifdef ASSERT
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1066
  bool is_on_master_free_list(HeapRegion* hr) {
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1067
    return _hrm.is_free(hr);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1068
  }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1069
#endif // ASSERT
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1070
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1071
  // Wrapper for the region list operations that can be called from
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1072
  // methods outside this class.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1073
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
  1074
  void secondary_free_list_add(FreeRegionList* list) {
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23457
diff changeset
  1075
    _secondary_free_list.add_ordered(list);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1076
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1077
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1078
  void append_secondary_free_list() {
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1079
    _hrm.insert_list_into_free_list(&_secondary_free_list);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1080
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1081
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1082
  void append_secondary_free_list_if_not_empty_with_lock() {
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1083
    // If the secondary free list looks empty there's no reason to
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1084
    // take the lock and then try to append it.
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1085
    if (!_secondary_free_list.is_empty()) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1086
      MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1087
      append_secondary_free_list();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1088
    }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1089
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1090
32193
862a68285b1e 8133042: Remove some direct accesses of G1Allocator to G1CollectedHeap members
tschatzl
parents: 32187
diff changeset
  1091
  inline void old_set_add(HeapRegion* hr);
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1092
  inline void old_set_remove(HeapRegion* hr);
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1093
11576
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1094
  size_t non_young_capacity_bytes() {
35065
b4ff0249c092 8144996: Replace the HeapRegionSetCount class with an uint
david
parents: 35061
diff changeset
  1095
    return (_old_set.length() + _humongous_set.length()) * HeapRegion::GrainBytes;
11576
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1096
  }
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1097
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1098
  void set_free_regions_coming();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1099
  void reset_free_regions_coming();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1100
  bool free_regions_coming() { return _free_regions_coming; }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1101
  void wait_while_free_regions_coming();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1102
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1103
  // Determine whether the given region is one that we are using as an
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1104
  // old GC alloc region.
32378
8dd0e7359751 8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents: 32360
diff changeset
  1105
  bool is_old_gc_alloc_region(HeapRegion* hr);
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1106
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1107
  // Perform a collection of the heap; intended for use in implementing
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1108
  // "System.gc".  This probably implies as full a collection as the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1109
  // "CollectedHeap" supports.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1110
  virtual void collect(GCCause::Cause cause);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1111
27623
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 27439
diff changeset
  1112
  virtual bool copy_allocation_context_stats(const jint* contexts,
26842
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26841
diff changeset
  1113
                                             jlong* totals,
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26841
diff changeset
  1114
                                             jbyte* accuracy,
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26841
diff changeset
  1115
                                             jint len);
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26841
diff changeset
  1116
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1117
  // True iff an evacuation has failed in the most-recent collection.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1118
  bool evacuation_failed() { return _evacuation_failed; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1119
35065
b4ff0249c092 8144996: Replace the HeapRegionSetCount class with an uint
david
parents: 35061
diff changeset
  1120
  void remove_from_old_sets(const uint old_regions_removed, const uint humongous_regions_removed);
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
  1121
  void prepend_to_freelist(FreeRegionList* list);
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22904
diff changeset
  1122
  void decrement_summary_bytes(size_t bytes);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1123
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1124
  virtual bool is_in(const void* p) const;
26160
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1125
#ifdef ASSERT
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1126
  // Returns whether p is in one of the available areas of the heap. Slow but
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1127
  // extensive version.
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1128
  bool is_in_exact(const void* p) const;
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1129
#endif
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1130
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1131
  // Return "TRUE" iff the given object address is within the collection
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1132
  // set. Slow implementation.
32185
49a57ff2c3cb 8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents: 31976
diff changeset
  1133
  bool obj_in_cs(oop obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1134
29470
e34bbcd36e53 8030646: track collection set membership in one place
ehelin
parents: 29465
diff changeset
  1135
  inline bool is_in_cset(const HeapRegion *hr);
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1136
  inline bool is_in_cset(oop obj);
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1137
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1138
  inline bool is_in_cset_or_humongous(const oop obj);
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1139
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1140
 private:
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1141
  // This array is used for a quick test on whether a reference points into
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1142
  // the collection set or not. Each of the array's elements denotes whether the
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1143
  // corresponding region is in the collection set or not.
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
  1144
  G1InCSetStateFastTestBiasedMappedArray _in_cset_fast_test;
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1145
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1146
 public:
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1147
28213
b0bf57cd1e9d 8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents: 28207
diff changeset
  1148
  inline InCSetState in_cset_state(const oop obj);
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1149
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1150
  // Return "TRUE" iff the given object address is in the reserved
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1151
  // region of g1.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1152
  bool is_in_g1_reserved(const void* p) const {
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1153
    return _hrm.reserved().contains(p);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1154
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1155
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1156
  // Returns a MemRegion that corresponds to the space that has been
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1157
  // reserved for the heap
26157
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
  1158
  MemRegion g1_reserved() const {
26316
93f6b40c038b 8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents: 26314
diff changeset
  1159
    return _hrm.reserved();
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1160
  }
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1161
8485
e84ccd8664ba 7022200: G1: optimized build broken
johnc
parents: 8103
diff changeset
  1162
  virtual bool is_in_closed_subset(const void* p) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1163
26160
aba6b01cb988 8038423: G1: Decommit memory within heap
tschatzl
parents: 26159
diff changeset
  1164
  G1SATBCardTableLoggingModRefBS* g1_barrier_set() {
29325
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 29078
diff changeset
  1165
    return barrier_set_cast<G1SATBCardTableLoggingModRefBS>(barrier_set());
20309
7445302daff6 8025305: Cleanup CardTableModRefBS usage in G1
mgerdin
parents: 19986
diff changeset
  1166
  }
7445302daff6 8025305: Cleanup CardTableModRefBS usage in G1
mgerdin
parents: 19986
diff changeset
  1167
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1168
  // Iteration functions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1169
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1170
  // Iterate over all objects, calling "cl.do_object" on each.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1171
  virtual void object_iterate(ObjectClosure* cl);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1172
2345
3098a48a7240 6822263: G1: JVMTI heap iteration fails
iveresov
parents: 2344
diff changeset
  1173
  virtual void safe_object_iterate(ObjectClosure* cl) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1174
    object_iterate(cl);
2345
3098a48a7240 6822263: G1: JVMTI heap iteration fails
iveresov
parents: 2344
diff changeset
  1175
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1176
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1177
  // Iterate over heap regions, in address order, terminating the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1178
  // iteration early if the "doHeapRegion" method returns "true".
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1179
  void heap_region_iterate(HeapRegionClosure* blk) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1180
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1181
  // Return the region with the given index. It assumes the index is valid.
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1182
  inline HeapRegion* region_at(uint index) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1183
33786
ac8da6513351 8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents: 33609
diff changeset
  1184
  // Return the next region (by index) that is part of the same
ac8da6513351 8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents: 33609
diff changeset
  1185
  // humongous object that hr is part of.
ac8da6513351 8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents: 33609
diff changeset
  1186
  inline HeapRegion* next_region_in_humongous(HeapRegion* hr) const;
ac8da6513351 8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents: 33609
diff changeset
  1187
25889
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1188
  // Calculate the region index of the given address. Given address must be
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1189
  // within the heap.
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1190
  inline uint addr_to_region(HeapWord* addr) const;
221296ac4359 8027959: Early reclamation of large objects in G1
tschatzl
parents: 25730
diff changeset
  1191
26157
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
  1192
  inline HeapWord* bottom_addr_for_region(uint index) const;
70eddb655686 8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents: 25942
diff changeset
  1193
27009
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1194
  // Iterate over the heap regions in parallel. Assumes that this will be called
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1195
  // in parallel by ParallelGCThreads worker threads with distinct worker ids
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1196
  // in the range [0..max(ParallelGCThreads-1, 1)]. Applies "blk->doHeapRegion"
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1197
  // to each of the regions, by attempting to claim the region using the
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1198
  // HeapRegionClaimer and, if successful, applying the closure to the claimed
27885
7786b3940066 8062943: REDO - Parallelize clearing the next mark bitmap
mlarsson
parents: 27623
diff changeset
  1199
  // region. The concurrent argument should be set to true if iteration is
7786b3940066 8062943: REDO - Parallelize clearing the next mark bitmap
mlarsson
parents: 27623
diff changeset
  1200
  // performed concurrently, during which no assumptions are made for consistent
7786b3940066 8062943: REDO - Parallelize clearing the next mark bitmap
mlarsson
parents: 27623
diff changeset
  1201
  // attributes of the heap regions (as they might be modified while iterating).
27009
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1202
  void heap_region_par_iterate(HeapRegionClosure* cl,
e7e723732b6b 8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents: 26846
diff changeset
  1203
                               uint worker_id,
27885
7786b3940066 8062943: REDO - Parallelize clearing the next mark bitmap
mlarsson
parents: 27623
diff changeset
  1204
                               HeapRegionClaimer* hrclaimer,
7786b3940066 8062943: REDO - Parallelize clearing the next mark bitmap
mlarsson
parents: 27623
diff changeset
  1205
                               bool concurrent = false) const;
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1385
diff changeset
  1206
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1207
  // Iterate over the regions (if any) in the current collection set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1208
  void collection_set_iterate(HeapRegionClosure* blk);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1209
39698
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
  1210
  // Iterate over the regions (if any) in the current collection set. Starts the
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
  1211
  // iteration over the entire collection set so that the start regions of a given
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
  1212
  // worker id over the set active_workers are evenly spread across the set of
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
  1213
  // collection set regions.
4016de4e596b 8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents: 38186
diff changeset
  1214
  void collection_set_iterate_from(HeapRegionClosure *blk, uint worker_id);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1215
25730
7eb4e685f739 8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents: 25492
diff changeset
  1216
  HeapRegion* next_compaction_region(const HeapRegion* from) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1217
24106
dae9277bdf2a 8040722: G1: Clean up usages of heap_region_containing
brutisso
parents: 24103
diff changeset
  1218
  // Returns the HeapRegion that contains addr. addr must not be NULL.
dae9277bdf2a 8040722: G1: Clean up usages of heap_region_containing
brutisso
parents: 24103
diff changeset
  1219
  template <class T>
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1220
  inline HeapRegion* heap_region_containing(const T addr) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1221
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1222
  // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1223
  // each address in the (reserved) heap is a member of exactly
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1224
  // one block.  The defining characteristic of a block is that it is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1225
  // possible to find its size, and thus to progress forward to the next
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1226
  // block.  (Blocks may be of different sizes.)  Thus, blocks may
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1227
  // represent Java objects, or they might be free blocks in a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1228
  // free-list-based heap (or subheap), as long as the two kinds are
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1229
  // distinguishable and the size of each is determinable.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1230
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1231
  // Returns the address of the start of the "block" that contains the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1232
  // address "addr".  We say "blocks" instead of "object" since some heaps
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1233
  // may not pack objects densely; a chunk may either be an object or a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1234
  // non-object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1235
  virtual HeapWord* block_start(const void* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1236
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1237
  // Requires "addr" to be the start of a chunk, and returns its size.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1238
  // "addr + size" is required to be the start of a new chunk, or the end
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1239
  // of the active area of the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1240
  virtual size_t block_size(const HeapWord* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1241
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1242
  // Requires "addr" to be the start of a block, and returns "TRUE" iff
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1243
  // the block is an object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1244
  virtual bool block_is_obj(const HeapWord* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1245
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1246
  // Section on thread-local allocation buffers (TLABs)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1247
  // See CollectedHeap for semantics.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1248
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1249
  bool supports_tlab_allocation() const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1250
  size_t tlab_capacity(Thread* ignored) const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1251
  size_t tlab_used(Thread* ignored) const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1252
  size_t max_tlab_size() const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1253
  size_t unsafe_max_tlab_alloc(Thread* ignored) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1254
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1255
  // Can a compiler initialize a new object without store barriers?
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1256
  // This permission only extends from the creation of a new object
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1257
  // via a TLAB up to the first subsequent safepoint. If such permission
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1258
  // is granted for this heap type, the compiler promises to call
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1259
  // defer_store_barrier() below on any slow path allocation of
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1260
  // a new object for which such initializing store barriers will
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1261
  // have been elided. G1, like CMS, allows this, but should be
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1262
  // ready to provide a compensating write barrier as necessary
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1263
  // if that storage came out of a non-young region. The efficiency
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1264
  // of this implementation depends crucially on being able to
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1265
  // answer very efficiently in constant time whether a piece of
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1266
  // storage in the heap comes from a young region or not.
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1267
  // See ReduceInitialCardMarks.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1268
  virtual bool can_elide_tlab_store_barriers() const {
10679
f598a613d73e 7005808: G1: re-enable ReduceInitialCardMarks for G1
brutisso
parents: 10671
diff changeset
  1269
    return true;
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1270
  }
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1271
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1272
  virtual bool card_mark_must_follow_store() const {
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1273
    return true;
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1274
  }
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1275
37129
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1276
  // The reference pending list lock is acquired from from the
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1277
  // ConcurrentMarkThread.
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1278
  virtual bool needs_reference_pending_list_locker_thread() const {
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1279
    return true;
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1280
  }
af29e306e50b 8151601: Cleanup locking of the Reference pending list
pliden
parents: 37085
diff changeset
  1281
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1282
  inline bool is_in_young(const oop obj);
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1283
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1284
  virtual bool is_scavengable(const void* addr);
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1285
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1286
  // We don't need barriers for initializing stores to objects
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1287
  // in the young gen: for the SATB pre-barrier, there is no
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1288
  // pre-value that needs to be remembered; for the remembered-set
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1289
  // update logging post-barrier, we don't maintain remembered set
10280
3463715b5ef7 6814390: G1: remove the concept of non-generational G1
brutisso
parents: 10243
diff changeset
  1290
  // information for young gen objects.
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1291
  virtual inline bool can_elide_initializing_store_barrier(oop new_obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1292
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1293
  // Returns "true" iff the given word_size is "very large".
26846
7d4376f8560e 8058495: G1: normalize names for isHumongous() and friends
tonyp
parents: 26842
diff changeset
  1294
  static bool is_humongous(size_t word_size) {
5078
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1295
    // Note this has to be strictly greater-than as the TLABs
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22547
diff changeset
  1296
    // are capped at the humongous threshold and we want to
5078
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1297
    // ensure that we don't try to allocate a TLAB as
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1298
    // humongous and that we don't allocate a humongous
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1299
    // object in a TLAB.
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1300
    return word_size > _humongous_object_threshold_in_words;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1301
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1302
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1303
  // Returns the humongous threshold for a specific region size
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1304
  static size_t humongous_threshold_for(size_t region_size) {
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1305
    return (region_size / 2);
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1306
  }
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1307
34298
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34241
diff changeset
  1308
  // Returns the number of regions the humongous object of the given word size
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34241
diff changeset
  1309
  // requires.
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34241
diff changeset
  1310
  static size_t humongous_obj_size_in_regions(size_t word_size);
f3c9dcc5af96 8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents: 34241
diff changeset
  1311
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1312
  // Print the maximum heap capacity.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1313
  virtual size_t max_capacity() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1314
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1315
  virtual jlong millis_since_last_gc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1316
10000
5bbb58b0dbb9 7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents: 9997
diff changeset
  1317
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1318
  // Convenience function to be used in situations where the heap type can be
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1319
  // asserted to be this type.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1320
  static G1CollectedHeap* heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1321
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1322
  void set_region_short_lived_locked(HeapRegion* hr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1323
  // add appropriate methods for any other surv rate groups
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1324
38183
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1325
  const G1SurvivorRegions* survivor() const { return &_survivor; }
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1326
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1327
  uint survivor_regions_count() const {
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1328
    return _survivor.length();
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1329
  }
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1330
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1331
  uint eden_regions_count() const {
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1332
    return _eden.length();
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1333
  }
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1334
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1335
  uint young_regions_count() const {
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1336
    return _eden.length() + _survivor.length();
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1337
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1338
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
  1339
  uint old_regions_count() const { return _old_set.length(); }
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
  1340
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
  1341
  uint humongous_regions_count() const { return _humongous_set.length(); }
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
  1342
38183
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1343
#ifdef ASSERT
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1344
  bool check_young_list_empty();
cb68e4923223 8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents: 38172
diff changeset
  1345
#endif
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1346
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1347
  // *** Stuff related to concurrent marking.  It's not clear to me that so
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1348
  // many of these need to be public.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1349
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1350
  // The functions below are helper functions that a subclass of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1351
  // "CollectedHeap" can use in the implementation of its virtual
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1352
  // functions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1353
  // This performs a concurrent marking of the live objects in a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1354
  // bitmap off to the side.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1355
  void doConcurrentMark();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1356
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1357
  bool isMarkedPrev(oop obj) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1358
  bool isMarkedNext(oop obj) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1359
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1360
  // Determine if an object is dead, given the object and also
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1361
  // the region to which the object belongs. An object is dead
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1362
  // iff a) it was not allocated since the last mark, b) it
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1363
  // is not marked, and c) it is not in an archive region.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1364
  bool is_obj_dead(const oop obj, const HeapRegion* hr) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1365
    return
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1366
      !hr->obj_allocated_since_prev_marking(obj) &&
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1367
      !isMarkedPrev(obj) &&
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1368
      !hr->is_archive();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1369
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1370
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1371
  // This function returns true when an object has been
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1372
  // around since the previous marking and hasn't yet
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1373
  // been marked during this marking, and is not in an archive region.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1374
  bool is_obj_ill(const oop obj, const HeapRegion* hr) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1375
    return
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1376
      !hr->obj_allocated_since_next_marking(obj) &&
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1377
      !isMarkedNext(obj) &&
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 31344
diff changeset
  1378
      !hr->is_archive();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1379
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1380
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1381
  // Determine if an object is dead, given only the object itself.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1382
  // This will find the region to which the object belongs and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1383
  // then call the region version of the same function.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1384
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1385
  // Added if it is NULL it isn't dead.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1386
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1387
  inline bool is_obj_dead(const oop obj) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1388
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1389
  inline bool is_obj_ill(const oop obj) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1390
35943
e726308008c0 8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents: 35909
diff changeset
  1391
  G1ConcurrentMark* concurrent_mark() const { return _cm; }
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1392
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1393
  // Refinement
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1394
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1395
  ConcurrentG1Refine* concurrent_g1_refine() const { return _cg1r; }
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1396
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1397
  // Optimized nmethod scanning support routines
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1398
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22547
diff changeset
  1399
  // Register the given nmethod with the G1 heap.
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1400
  virtual void register_nmethod(nmethod* nm);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1401
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22547
diff changeset
  1402
  // Unregister the given nmethod from the G1 heap.
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1403
  virtual void unregister_nmethod(nmethod* nm);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1404
23451
ed2b8bb28fed 8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents: 23450
diff changeset
  1405
  // Free up superfluous code root memory.
ed2b8bb28fed 8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents: 23450
diff changeset
  1406
  void purge_code_root_memory();
ed2b8bb28fed 8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents: 23450
diff changeset
  1407
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22547
diff changeset
  1408
  // Rebuild the strong code root lists for each region
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22547
diff changeset
  1409
  // after a full GC.
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1410
  void rebuild_strong_code_roots();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1411
22545
b93a7f0e9b9d 8027476: Improve performance of Stringtable unlink
tschatzl
parents: 22203
diff changeset
  1412
  // Delete entries for dead interned string and clean up unreferenced symbols
b93a7f0e9b9d 8027476: Improve performance of Stringtable unlink
tschatzl
parents: 22203
diff changeset
  1413
  // in symbol table, possibly in parallel.
b93a7f0e9b9d 8027476: Improve performance of Stringtable unlink
tschatzl
parents: 22203
diff changeset
  1414
  void unlink_string_and_symbol_table(BoolObjectClosure* is_alive, bool unlink_strings = true, bool unlink_symbols = true);
b93a7f0e9b9d 8027476: Improve performance of Stringtable unlink
tschatzl
parents: 22203
diff changeset
  1415
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
  1416
  // Parallel phase of unloading/cleaning after G1 concurrent mark.
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
  1417
  void parallel_cleaning(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols, bool class_unloading_occurred);
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
  1418
23454
13a3b426f64d 8035398: Add card redirty time in "Other" time in G1
tschatzl
parents: 23453
diff changeset
  1419
  // Redirty logged cards in the refinement queue.
13a3b426f64d 8035398: Add card redirty time in "Other" time in G1
tschatzl
parents: 23453
diff changeset
  1420
  void redirty_logged_cards();
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1421
  // Verification
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1422
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1423
  // Perform any cleanup actions necessary before allowing a verification.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1424
  virtual void prepare_for_verify();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1425
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1426
  // Perform verification.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1427
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1428
  // vo == UsePrevMarking  -> use "prev" marking information,
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1429
  // vo == UseNextMarking -> use "next" marking information
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1430
  // vo == UseMarkWord    -> use the mark word in the object header
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1431
  //
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1432
  // NOTE: Only the "prev" marking information is guaranteed to be
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1433
  // consistent most of the time, so most calls to this should use
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1434
  // vo == UsePrevMarking.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1435
  // Currently, there is only one case where this is called with
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1436
  // vo == UseNextMarking, which is to verify the "next" marking
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1437
  // information at the end of remark.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1438
  // Currently there is only one place where this is called with
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1439
  // vo == UseMarkWord, which is to verify the marking during a
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1440
  // full GC.
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 35051
diff changeset
  1441
  void verify(VerifyOption vo);
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1442
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1443
  // The methods below are here for convenience and dispatch the
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1444
  // appropriate method depending on value of the given VerifyOption
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1445
  // parameter. The values for that parameter, and their meanings,
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1446
  // are the same as those above.
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1447
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1448
  bool is_obj_dead_cond(const oop obj,
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1449
                        const HeapRegion* hr,
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1450
                        const VerifyOption vo) const;
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1451
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1452
  bool is_obj_dead_cond(const oop obj,
23543
0625da57ab78 8038498: Fix includes and C inlining after 8035330
goetz
parents: 23471
diff changeset
  1453
                        const VerifyOption vo) const;
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1454
31344
2316eb7a0358 8025608: GC trace events missing nursery size information
david
parents: 31331
diff changeset
  1455
  G1HeapSummary create_g1_heap_summary();
32380
1dcdb686f0cb 8133530: Add JFR event for evacuation statistics
tschatzl
parents: 32379
diff changeset
  1456
  G1EvacSummary create_g1_evac_summary(G1EvacStats* stats);
31344
2316eb7a0358 8025608: GC trace events missing nursery size information
david
parents: 31331
diff changeset
  1457
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1458
  // Printing
37085
53ccf09a724f 8151696: Print all regions on trace level to get same behavior as old PrintHeapAtGCExtended
sjohanss
parents: 37039
diff changeset
  1459
private:
53ccf09a724f 8151696: Print all regions on trace level to get same behavior as old PrintHeapAtGCExtended
sjohanss
parents: 37039
diff changeset
  1460
  void print_heap_regions() const;
53ccf09a724f 8151696: Print all regions on trace level to get same behavior as old PrintHeapAtGCExtended
sjohanss
parents: 37039
diff changeset
  1461
  void print_regions_on(outputStream* st) const;
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1462
37085
53ccf09a724f 8151696: Print all regions on trace level to get same behavior as old PrintHeapAtGCExtended
sjohanss
parents: 37039
diff changeset
  1463
public:
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1464
  virtual void print_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1465
  virtual void print_extended_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1466
  virtual void print_on_error(outputStream* st) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1467
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1468
  virtual void print_gc_threads_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1469
  virtual void gc_threads_do(ThreadClosure* tc) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1470
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1471
  // Override
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1472
  void print_tracing_info() const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1473
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1474
  // The following two methods are helpful for debugging RSet issues.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1475
  void print_cset_rsets() PRODUCT_RETURN;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1476
  void print_all_rsets() PRODUCT_RETURN;
2883
406d1e6d1aa1 6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents: 2345
diff changeset
  1477
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1478
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1479
  size_t pending_card_num();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1480
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1481
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1482
  size_t _max_heap_capacity;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1483
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1484
34296
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1485
class G1ParEvacuateFollowersClosure : public VoidClosure {
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1486
private:
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1487
  double _start_term;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1488
  double _term_time;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1489
  size_t _term_attempts;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1490
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1491
  void start_term_time() { _term_attempts++; _start_term = os::elapsedTime(); }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1492
  void end_term_time() { _term_time += os::elapsedTime() - _start_term; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1493
protected:
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1494
  G1CollectedHeap*              _g1h;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1495
  G1ParScanThreadState*         _par_scan_state;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1496
  RefToScanQueueSet*            _queues;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1497
  ParallelTaskTerminator*       _terminator;
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1498
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1499
  G1ParScanThreadState*   par_scan_state() { return _par_scan_state; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1500
  RefToScanQueueSet*      queues()         { return _queues; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1501
  ParallelTaskTerminator* terminator()     { return _terminator; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1502
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1503
public:
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1504
  G1ParEvacuateFollowersClosure(G1CollectedHeap* g1h,
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1505
                                G1ParScanThreadState* par_scan_state,
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1506
                                RefToScanQueueSet* queues,
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1507
                                ParallelTaskTerminator* terminator)
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1508
    : _g1h(g1h), _par_scan_state(par_scan_state),
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1509
      _queues(queues), _terminator(terminator),
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1510
      _start_term(0.0), _term_time(0.0), _term_attempts(0) {}
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1511
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1512
  void do_void();
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1513
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1514
  double term_time() const { return _term_time; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1515
  size_t term_attempts() const { return _term_attempts; }
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1516
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1517
private:
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1518
  inline bool offer_termination();
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1519
};
ef50f39866b5 8142495: Move G1ParEvacuateFollowersClosure to header file
ehelin
parents: 34241
diff changeset
  1520
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30586
diff changeset
  1521
#endif // SHARE_VM_GC_G1_G1COLLECTEDHEAP_HPP