hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
author tschatzl
Wed, 11 Sep 2013 16:25:02 +0200
changeset 19986 33d188c66ed9
parent 19549 60e5c7cafdca
child 20309 7445302daff6
child 20282 7f9cbdf89af2
permissions -rw-r--r--
8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes
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
/*
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
     2
 * Copyright (c) 2001, 2013, 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
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    25
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    26
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    28
#include "gc_implementation/g1/concurrentMark.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    29
#include "gc_implementation/g1/evacuationInfo.hpp"
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
    30
#include "gc_implementation/g1/g1AllocRegion.hpp"
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
    31
#include "gc_implementation/g1/g1HRPrinter.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    32
#include "gc_implementation/g1/g1MonitoringSupport.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    33
#include "gc_implementation/g1/g1RemSet.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    34
#include "gc_implementation/g1/g1YCTypes.hpp"
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
    35
#include "gc_implementation/g1/heapRegionSeq.hpp"
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
    36
#include "gc_implementation/g1/heapRegionSets.hpp"
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
    37
#include "gc_implementation/shared/hSpaceCounters.hpp"
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
    38
#include "gc_implementation/shared/parGCAllocBuffer.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    39
#include "memory/barrierSet.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    40
#include "memory/memRegion.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    41
#include "memory/sharedHeap.hpp"
15608
a1fd1fc60c7d 8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents: 13926
diff changeset
    42
#include "utilities/stack.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
    43
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    44
// A "G1CollectedHeap" is an implementation of a java heap for HotSpot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    45
// It uses the "Garbage First" heap organization and algorithm, which
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    46
// may combine concurrent marking with parallel, incremental compaction of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    47
// heap subsets that will yield large amounts of garbage.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    48
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
    49
// Forward declarations
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    50
class HeapRegion;
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
    51
class HRRSCleanupTask;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    52
class GenerationSpec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    53
class OopsInHeapRegionClosure;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
    54
class G1KlassScanClosure;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    55
class G1ScanHeapEvacClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    56
class ObjectClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    57
class SpaceClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    58
class CompactibleSpaceClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    59
class Space;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    60
class G1CollectorPolicy;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    61
class GenRemSet;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    62
class G1RemSet;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    63
class HeapRegionRemSetIterator;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    64
class ConcurrentMark;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    65
class ConcurrentMarkThread;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    66
class ConcurrentG1Refine;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    67
class ConcurrentGCTimer;
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
    68
class GenerationCounters;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    69
class STWGCTimer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    70
class G1NewTracer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    71
class G1OldTracer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
    72
class EvacuationFailedInfo;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
    73
class nmethod;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    74
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
    75
typedef OverflowTaskQueue<StarTask, mtGC>         RefToScanQueue;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
    76
typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    77
2996
1097030e5ec3 6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents: 2883
diff changeset
    78
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
    79
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
    80
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    81
enum GCAllocPurpose {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    82
  GCAllocForTenured,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    83
  GCAllocForSurvived,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    84
  GCAllocPurposeCount
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    85
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    86
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
    87
class YoungList : public CHeapObj<mtGC> {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    88
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    89
  G1CollectedHeap* _g1h;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    90
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    91
  HeapRegion* _head;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    92
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
    93
  HeapRegion* _survivor_head;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
    94
  HeapRegion* _survivor_tail;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
    95
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
    96
  HeapRegion* _curr;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
    97
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
    98
  uint        _length;
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
    99
  uint        _survivor_length;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   100
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   101
  size_t      _last_sampled_rs_lengths;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   102
  size_t      _sampled_rs_lengths;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   103
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   104
  void         empty_list(HeapRegion* list);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   105
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   106
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   107
  YoungList(G1CollectedHeap* g1h);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   108
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   109
  void         push_region(HeapRegion* hr);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   110
  void         add_survivor_region(HeapRegion* hr);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   111
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   112
  void         empty_list();
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   113
  bool         is_empty() { return _length == 0; }
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   114
  uint         length() { return _length; }
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   115
  uint         survivor_length() { return _survivor_length; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   116
9987
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   117
  // Currently we do not keep track of the used byte sum for the
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   118
  // young list and the survivors and it'd be quite a lot of work to
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   119
  // do so. When we'll eventually replace the young list with
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   120
  // instances of HeapRegionLinkedList we'll get that for free. So,
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   121
  // we'll report the more accurate information then.
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   122
  size_t       eden_used_bytes() {
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   123
    assert(length() >= survivor_length(), "invariant");
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   124
    return (size_t) (length() - survivor_length()) * HeapRegion::GrainBytes;
9987
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   125
  }
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   126
  size_t       survivor_used_bytes() {
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   127
    return (size_t) survivor_length() * HeapRegion::GrainBytes;
9987
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   128
  }
6e2b9796996f 7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents: 9935
diff changeset
   129
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   130
  void rs_length_sampling_init();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   131
  bool rs_length_sampling_more();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   132
  void rs_length_sampling_next();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   133
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   134
  void reset_sampled_info() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   135
    _last_sampled_rs_lengths =   0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   136
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   137
  size_t sampled_rs_lengths() { return _last_sampled_rs_lengths; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   138
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   139
  // for development purposes
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   140
  void reset_auxilary_lists();
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   141
  void clear() { _head = NULL; _length = 0; }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   142
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   143
  void clear_survivors() {
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   144
    _survivor_head    = NULL;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   145
    _survivor_tail    = NULL;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   146
    _survivor_length  = 0;
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   147
  }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   148
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   149
  HeapRegion* first_region() { return _head; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   150
  HeapRegion* first_survivor_region() { return _survivor_head; }
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1902
diff changeset
   151
  HeapRegion* last_survivor_region() { return _survivor_tail; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   152
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   153
  // debugging
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   154
  bool          check_list_well_formed();
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   155
  bool          check_list_empty(bool check_sample = true);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   156
  void          print();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   157
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   158
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   159
class MutatorAllocRegion : public G1AllocRegion {
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   160
protected:
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   161
  virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   162
  virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   163
public:
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   164
  MutatorAllocRegion()
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   165
    : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   166
};
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   167
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   168
class SurvivorGCAllocRegion : public G1AllocRegion {
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   169
protected:
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   170
  virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   171
  virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   172
public:
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   173
  SurvivorGCAllocRegion()
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   174
  : G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { }
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   175
};
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   176
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   177
class OldGCAllocRegion : public G1AllocRegion {
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   178
protected:
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   179
  virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   180
  virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   181
public:
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   182
  OldGCAllocRegion()
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   183
  : G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { }
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   184
};
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   185
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   186
// The G1 STW is alive closure.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   187
// An instance is embedded into the G1CH and used as the
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   188
// (optional) _is_alive_non_header closure in the STW
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   189
// reference processor. It is also extensively used during
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   190
// reference processing during STW evacuation pauses.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   191
class G1STWIsAliveClosure: public BoolObjectClosure {
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   192
  G1CollectedHeap* _g1;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   193
public:
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   194
  G1STWIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   195
  bool do_object_b(oop p);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   196
};
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
   197
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   198
class RefineCardTableEntryClosure;
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   199
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   200
class G1CollectedHeap : public SharedHeap {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   201
  friend class VM_G1CollectForAllocation;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   202
  friend class VM_G1CollectFull;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   203
  friend class VM_G1IncCollectionPause;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   204
  friend class VMStructs;
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   205
  friend class MutatorAllocRegion;
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   206
  friend class SurvivorGCAllocRegion;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   207
  friend class OldGCAllocRegion;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   208
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   209
  // Closures used in implementation.
12271
8cf95843833b 7130974: G1: Remove G1ParCopyHelper
brutisso
parents: 11756
diff changeset
   210
  template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
8cf95843833b 7130974: G1: Remove G1ParCopyHelper
brutisso
parents: 11756
diff changeset
   211
  friend class G1ParCopyClosure;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   212
  friend class G1IsAliveClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   213
  friend class G1EvacuateFollowersClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   214
  friend class G1ParScanThreadState;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   215
  friend class G1ParScanClosureSuper;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   216
  friend class G1ParEvacuateFollowersClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   217
  friend class G1ParTask;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   218
  friend class G1FreeGarbageRegionClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   219
  friend class RefineCardTableEntryClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   220
  friend class G1PrepareCompactClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   221
  friend class RegionSorter;
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   222
  friend class RegionResetter;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   223
  friend class CountRCClosure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   224
  friend class EvacPopObjClosure;
2883
406d1e6d1aa1 6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents: 2345
diff changeset
   225
  friend class G1ParCleanupCTTask;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   226
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   227
  // Other related classes.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   228
  friend class G1MarkSweep;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   229
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   230
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   231
  // The one and only G1CollectedHeap, so static functions can find it.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   232
  static G1CollectedHeap* _g1h;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   233
3697
ea9211aa02f5 6819085: G1: use larger and/or user settable region size
tonyp
parents: 3696
diff changeset
   234
  static size_t _humongous_object_threshold_in_words;
ea9211aa02f5 6819085: G1: use larger and/or user settable region size
tonyp
parents: 3696
diff changeset
   235
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   236
  // Storage for the G1 heap.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   237
  VirtualSpace _g1_storage;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   238
  MemRegion    _g1_reserved;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   239
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   240
  // The part of _g1_storage that is currently committed.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   241
  MemRegion _g1_committed;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   242
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   243
  // The master free list. It will satisfy all new region allocations.
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   244
  MasterFreeRegionList      _free_list;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   245
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   246
  // The secondary free list which contains regions that have been
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   247
  // freed up during the cleanup process. This will be appended to the
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   248
  // master free list when appropriate.
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   249
  SecondaryFreeRegionList   _secondary_free_list;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   250
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   251
  // It keeps track of the old regions.
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   252
  MasterOldRegionSet        _old_set;
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   253
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   254
  // It keeps track of the humongous regions.
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   255
  MasterHumongousRegionSet  _humongous_set;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   256
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   257
  // 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
   258
  uint _expansion_regions;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   259
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   260
  // The block offset table for the G1 heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   261
  G1BlockOffsetSharedArray* _bot_shared;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   262
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   263
  // 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
   264
  // 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
   265
  // only exception is the humongous set which we leave unaltered. If
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   266
  // 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
   267
  // 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
   268
  // before heap shrinking (free_list_only == true).
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   269
  void tear_down_region_sets(bool free_list_only);
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   270
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   271
  // Rebuilds the region sets / lists so that they are repopulated to
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   272
  // reflect the contents of the heap. The only exception is the
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   273
  // humongous set which was not torn down in the first place. If
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   274
  // free_list_only is true, it will only rebuild the master free
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   275
  // 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
   276
  // after heap shrinking (free_list_only == true).
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
   277
  void rebuild_region_sets(bool free_list_only);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   278
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   279
  // The sequence of all heap regions in the heap.
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   280
  HeapRegionSeq _hrs;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   281
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   282
  // Alloc region used to satisfy mutator allocation requests.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   283
  MutatorAllocRegion _mutator_alloc_region;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   284
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   285
  // Alloc region used to satisfy allocation requests by the GC for
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   286
  // survivor objects.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   287
  SurvivorGCAllocRegion _survivor_gc_alloc_region;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   288
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   289
  // PLAB sizing policy for survivors.
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   290
  PLABStats _survivor_plab_stats;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   291
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   292
  // Alloc region used to satisfy allocation requests by the GC for
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   293
  // old objects.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   294
  OldGCAllocRegion _old_gc_alloc_region;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   295
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   296
  // PLAB sizing policy for tenured objects.
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   297
  PLABStats _old_plab_stats;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   298
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   299
  PLABStats* stats_for_purpose(GCAllocPurpose purpose) {
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   300
    PLABStats* stats = NULL;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   301
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   302
    switch (purpose) {
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   303
    case GCAllocForSurvived:
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   304
      stats = &_survivor_plab_stats;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   305
      break;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   306
    case GCAllocForTenured:
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   307
      stats = &_old_plab_stats;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   308
      break;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   309
    default:
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   310
      assert(false, "unrecognized GCAllocPurpose");
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   311
    }
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   312
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   313
    return stats;
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   314
  }
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   315
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   316
  // The last old region we allocated to during the last GC.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   317
  // Typically, it is not full so we should re-use it during the next GC.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   318
  HeapRegion* _retained_old_gc_alloc_region;
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   319
11449
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   320
  // 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
   321
  // 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
   322
  // 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
   323
  // 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
   324
  // 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
   325
  // start of each GC.
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   326
  bool _expand_heap_after_alloc_failure;
8abed3466567 7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents: 11396
diff changeset
   327
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   328
  // It resets the mutator alloc region before new allocations can take place.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   329
  void init_mutator_alloc_region();
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   330
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   331
  // It releases the mutator alloc region.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   332
  void release_mutator_alloc_region();
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   333
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   334
  // It initializes the GC alloc regions at the start of a GC.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   335
  void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   336
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   337
  // It releases the GC alloc regions at the end of a GC.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   338
  void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   339
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   340
  // It does any cleanup that needs to be done on the GC alloc regions
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   341
  // before a Full GC.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   342
  void abandon_gc_alloc_regions();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   343
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   344
  // Helper for monitoring and management support.
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   345
  G1MonitoringSupport* _g1mm;
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   346
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
   347
  // Determines PLAB size for a particular allocation purpose.
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
   348
  size_t desired_plab_sz(GCAllocPurpose purpose);
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
   349
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   350
  // Outside of GC pauses, the number of bytes used in all regions other
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   351
  // than the current allocation region.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   352
  size_t _summary_bytes_used;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   353
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   354
  // This is used for a quick test on whether a reference points into
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   355
  // the collection set or not. Basically, we have an array, with one
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   356
  // byte per region, and that byte denotes whether the corresponding
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   357
  // region is in the collection set or not. The entry corresponding
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   358
  // the bottom of the heap, i.e., region 0, is pointed to by
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   359
  // _in_cset_fast_test_base.  The _in_cset_fast_test field has been
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   360
  // biased so that it actually points to address 0 of the address
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   361
  // space, to make the test as fast as possible (we can simply shift
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   362
  // the address to address into it, instead of having to subtract the
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   363
  // bottom of the heap from the address before shifting it; basically
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   364
  // it works in the same way the card table works).
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   365
  bool* _in_cset_fast_test;
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   366
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   367
  // The allocated array used for the fast test on whether a reference
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   368
  // points into the collection set or not. This field is also used to
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   369
  // free the array.
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   370
  bool* _in_cset_fast_test_base;
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   371
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   372
  // The length of the _in_cset_fast_test_base array.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   373
  uint _in_cset_fast_test_length;
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   374
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
   375
  volatile unsigned _gc_time_stamp;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   376
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   377
  size_t* _surviving_young_words;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   378
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   379
  G1HRPrinter _hr_printer;
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   380
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   381
  void setup_surviving_young_words();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   382
  void update_surviving_young_words(size_t* surv_young_words);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   383
  void cleanup_surviving_young_words();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   384
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   385
  // 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
   386
  // 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
   387
  // explicitly started if:
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   388
  // (a) cause == _gc_locker and +GCLockerInvokesConcurrent, or
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   389
  // (b) cause == _java_lang_system_gc and +ExplicitGCInvokesConcurrent.
11576
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
   390
  // (c) cause == _g1_humongous_allocation
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   391
  bool should_do_concurrent_full_gc(GCCause::Cause cause);
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   392
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   393
  // 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
   394
  // concurrent cycles) we have started.
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   395
  volatile unsigned int _old_marking_cycles_started;
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   396
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   397
  // 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
   398
  // concurrent cycles) we have completed.
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   399
  volatile unsigned int _old_marking_cycles_completed;
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   400
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   401
  bool _concurrent_cycle_started;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   402
9334
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   403
  // 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
   404
  // 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
   405
  // 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
   406
  // frequent marking cycles and stress the cleanup / concurrent
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   407
  // 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
   408
  // 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
   409
  void allocate_dummy_regions() PRODUCT_RETURN;
640f1a6f0b85 7011855: G1: non-product flag to artificially grow the heap
tonyp
parents: 8930
diff changeset
   410
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   411
  // 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
   412
  void clear_rsets_post_compaction();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   413
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   414
  // 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
   415
  // heap after a compaction.
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   416
  void print_hrs_post_compaction();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
   417
13516
f7adc27fb367 7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents: 13482
diff changeset
   418
  double verify(bool guard, const char* msg);
f7adc27fb367 7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents: 13482
diff changeset
   419
  void verify_before_gc();
f7adc27fb367 7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents: 13482
diff changeset
   420
  void verify_after_gc();
f7adc27fb367 7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents: 13482
diff changeset
   421
13754
81163e1274d7 7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents: 13728
diff changeset
   422
  void log_gc_header();
81163e1274d7 7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents: 13728
diff changeset
   423
  void log_gc_footer(double pause_time_sec);
81163e1274d7 7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents: 13728
diff changeset
   424
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   425
  // 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
   426
  // line number, file, etc.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   427
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   428
#define heap_locking_asserts_err_msg(_extra_message_)                         \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   429
  err_msg("%s : Heap_lock locked: %s, at safepoint: %s, is VM thread: %s",    \
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   430
          (_extra_message_),                                                  \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   431
          BOOL_TO_STR(Heap_lock->owned_by_self()),                            \
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   432
          BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()),               \
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   433
          BOOL_TO_STR(Thread::current()->is_VM_thread()))
7398
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
#define assert_heap_locked()                                                  \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   436
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   437
    assert(Heap_lock->owned_by_self(),                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   438
           heap_locking_asserts_err_msg("should be holding the Heap_lock"));  \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   439
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   440
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   441
#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
   442
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   443
    assert(Heap_lock->owned_by_self() ||                                      \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   444
           (SafepointSynchronize::is_at_safepoint() &&                        \
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   445
             ((_should_be_vm_thread_) == Thread::current()->is_VM_thread())), \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   446
           heap_locking_asserts_err_msg("should be holding the Heap_lock or " \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   447
                                        "should be at a safepoint"));         \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   448
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   449
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   450
#define assert_heap_locked_and_not_at_safepoint()                             \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   451
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   452
    assert(Heap_lock->owned_by_self() &&                                      \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   453
                                    !SafepointSynchronize::is_at_safepoint(), \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   454
          heap_locking_asserts_err_msg("should be holding the Heap_lock and " \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   455
                                       "should not be at a safepoint"));      \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   456
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   457
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   458
#define assert_heap_not_locked()                                              \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   459
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   460
    assert(!Heap_lock->owned_by_self(),                                       \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   461
        heap_locking_asserts_err_msg("should not be holding the Heap_lock")); \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   462
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   463
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   464
#define assert_heap_not_locked_and_not_at_safepoint()                         \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   465
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   466
    assert(!Heap_lock->owned_by_self() &&                                     \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   467
                                    !SafepointSynchronize::is_at_safepoint(), \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   468
      heap_locking_asserts_err_msg("should not be holding the Heap_lock and " \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   469
                                   "should not be at a safepoint"));          \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   470
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   471
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   472
#define assert_at_safepoint(_should_be_vm_thread_)                            \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   473
  do {                                                                        \
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   474
    assert(SafepointSynchronize::is_at_safepoint() &&                         \
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   475
              ((_should_be_vm_thread_) == Thread::current()->is_VM_thread()), \
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   476
           heap_locking_asserts_err_msg("should be at a safepoint"));         \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   477
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   478
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   479
#define assert_not_at_safepoint()                                             \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   480
  do {                                                                        \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   481
    assert(!SafepointSynchronize::is_at_safepoint(),                          \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   482
           heap_locking_asserts_err_msg("should not be at a safepoint"));     \
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   483
  } while (0)
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   484
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   485
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   486
10236
c4256e927bed 7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents: 10001
diff changeset
   487
  // The young region list.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   488
  YoungList*  _young_list;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   489
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   490
  // The current policy object for the collector.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   491
  G1CollectorPolicy* _g1_policy;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   492
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   493
  // 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
   494
  // 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
   495
  // check whether there's anything available on the
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   496
  // 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
   497
  // that list, if _free_regions_coming is set.
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   498
  HeapRegion* new_region_try_secondary_free_list();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   499
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   500
  // Try to allocate a single non-humongous HeapRegion sufficient for
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   501
  // an allocation of the given word_size. If do_expand is true,
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   502
  // attempt to expand the heap if necessary to satisfy the allocation
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   503
  // request.
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   504
  HeapRegion* new_region(size_t word_size, bool do_expand);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   505
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   506
  // Attempt to satisfy a humongous allocation request of the given
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   507
  // size by finding a contiguous set of free regions of num_regions
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   508
  // length and remove them from the master free list. Return the
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   509
  // index of the first region or G1_NULL_HRS_INDEX if the search
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   510
  // was unsuccessful.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   511
  uint humongous_obj_allocate_find_first(uint num_regions,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   512
                                         size_t word_size);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   513
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   514
  // Initialize a contiguous set of free regions of length num_regions
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   515
  // and starting at index first so that they appear as a single
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   516
  // humongous region.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   517
  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
   518
                                                      uint num_regions,
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   519
                                                      size_t word_size);
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   520
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   521
  // Attempt to allocate a humongous object of the given size. Return
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   522
  // NULL if unsuccessful.
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   523
  HeapWord* humongous_obj_allocate(size_t word_size);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   524
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   525
  // The following two methods, allocate_new_tlab() and
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   526
  // mem_allocate(), are the two main entry points from the runtime
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   527
  // into the G1's allocation routines. They have the following
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   528
  // assumptions:
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   529
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   530
  // * They should both be called outside safepoints.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   531
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   532
  // * They should both be called without holding the Heap_lock.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   533
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   534
  // * All allocation requests for new TLABs should go to
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   535
  //   allocate_new_tlab().
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   536
  //
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   537
  // * All non-TLAB allocation requests should go to mem_allocate().
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   538
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   539
  // * If either call cannot satisfy the allocation request using the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   540
  //   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
   541
  //   this fails, they will attempt to do an evacuation pause and
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   542
  //   retry the allocation.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   543
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   544
  // * If all allocation attempts fail, even after trying to schedule
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   545
  //   an evacuation pause, allocate_new_tlab() will return NULL,
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   546
  //   whereas mem_allocate() will attempt a heap expansion and/or
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   547
  //   schedule a Full GC.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   548
  //
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   549
  // * We do not allow humongous-sized TLABs. So, allocate_new_tlab
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   550
  //   should never be called with word_size being humongous. All
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   551
  //   humongous allocation requests should go to mem_allocate() which
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   552
  //   will satisfy them with a special path.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   553
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   554
  virtual HeapWord* allocate_new_tlab(size_t word_size);
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   555
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   556
  virtual HeapWord* mem_allocate(size_t word_size,
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   557
                                 bool*  gc_overhead_limit_was_exceeded);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   558
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   559
  // 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
   560
  // 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
   561
  // 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
   562
  // 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
   563
  // 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
   564
  // 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
   565
  // 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
   566
  // Heap_lock just to read the GC count.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   567
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   568
  // 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
   569
  // 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
   570
  // should only be used for non-humongous allocations.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   571
  inline HeapWord* attempt_allocation(size_t word_size,
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   572
                                      unsigned int* gc_count_before_ret,
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   573
                                      int* gclocker_retry_count_ret);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   574
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   575
  // 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
   576
  // retry the allocation attempt, potentially scheduling a GC
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   577
  // 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
   578
  HeapWord* attempt_allocation_slow(size_t word_size,
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   579
                                    unsigned int* gc_count_before_ret,
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   580
                                    int* gclocker_retry_count_ret);
7905
cc7740616b03 6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents: 7904
diff changeset
   581
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   582
  // 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
   583
  // potentially schedule a GC pause.
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   584
  HeapWord* attempt_allocation_humongous(size_t word_size,
16604
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   585
                                         unsigned int* gc_count_before_ret,
800a65bfe347 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents: 15608
diff changeset
   586
                                         int* gclocker_retry_count_ret);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   587
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   588
  // 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
   589
  // 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
   590
  // 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
   591
  // or not.
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   592
  HeapWord* attempt_allocation_at_safepoint(size_t word_size,
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   593
                                       bool expect_null_mutator_alloc_region);
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   594
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   595
  // It dirties the cards that cover the block so that so that the post
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   596
  // write barrier never queues anything when updating objects on this
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   597
  // block. It is assumed (and in fact we assert) that the block
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   598
  // belongs to a young region.
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   599
  inline void dirty_young_block(HeapWord* start, size_t word_size);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   600
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   601
  // Allocate blocks during garbage collection. Will ensure an
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   602
  // allocation region, either by picking one or expanding the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   603
  // heap, and then allocate a block of the given size. The block
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   604
  // may not be a humongous - it must fit into a single heap region.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   605
  HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   606
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   607
  // Ensure that no further allocations can happen in "r", bearing in mind
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   608
  // that parallel threads might be attempting allocations.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   609
  void par_allocate_remaining_space(HeapRegion* r);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   610
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   611
  // Allocation attempt during GC for a survivor object / PLAB.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   612
  inline HeapWord* survivor_attempt_allocation(size_t word_size);
2009
4adf43957a1b 6484959: G1: introduce survivor spaces
apetrusenko
parents: 1902
diff changeset
   613
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   614
  // Allocation attempt during GC for an old object / PLAB.
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   615
  inline HeapWord* old_attempt_allocation(size_t word_size);
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   616
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   617
  // 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
   618
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   619
  // For mutator alloc regions.
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   620
  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
   621
  void retire_mutator_alloc_region(HeapRegion* alloc_region,
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   622
                                   size_t allocated_bytes);
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
   623
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   624
  // For GC alloc regions.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   625
  HeapRegion* new_gc_alloc_region(size_t word_size, uint count,
10243
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   626
                                  GCAllocPurpose ap);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   627
  void retire_gc_alloc_region(HeapRegion* alloc_region,
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   628
                              size_t allocated_bytes, GCAllocPurpose ap);
d00a21009f1f 7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents: 10236
diff changeset
   629
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   630
  // - if explicit_gc is true, the GC is for a System.gc() or a heap
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   631
  //   inspection request and should collect the entire heap
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   632
  // - if clear_all_soft_refs is true, all soft references should be
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   633
  //   cleared during the GC
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   634
  // - if explicit_gc is false, word_size describes the allocation that
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   635
  //   the GC should attempt (at least) to satisfy
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   636
  // - it returns false if it is unable to do the collection due to the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   637
  //   GC locker being active, true otherwise
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   638
  bool do_collection(bool explicit_gc,
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   639
                     bool clear_all_soft_refs,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   640
                     size_t word_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   641
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   642
  // Callback from VM_G1CollectFull operation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   643
  // Perform a full collection.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   644
  virtual void do_full_collection(bool clear_all_soft_refs);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   645
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   646
  // Resize the heap if necessary after a full collection.  If this is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   647
  // after a collect-for allocation, "word_size" is the allocation size,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   648
  // and will be considered part of the used portion of the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   649
  void resize_if_necessary_after_full_collection(size_t word_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   650
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   651
  // Callback from VM_G1CollectForAllocation operation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   652
  // This function does everything necessary/possible to satisfy a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   653
  // failed allocation request (including collection, expansion, etc.)
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   654
  HeapWord* satisfy_failed_allocation(size_t word_size, bool* succeeded);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   655
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   656
  // Attempting to expand the heap sufficiently
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   657
  // to support an allocation of the given "word_size".  If
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   658
  // successful, perform the allocation and return the address of the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   659
  // allocated block, or else "NULL".
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   660
  HeapWord* expand_and_allocate(size_t word_size);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   661
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   662
  // Process any reference objects discovered during
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   663
  // an incremental evacuation pause.
13926
289339903fcf 8000311: G1: ParallelGCThreads==0 broken
johnc
parents: 13758
diff changeset
   664
  void process_discovered_references(uint no_of_gc_workers);
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   665
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   666
  // Enqueue any remaining discovered references
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   667
  // after processing.
13926
289339903fcf 8000311: G1: ParallelGCThreads==0 broken
johnc
parents: 13758
diff changeset
   668
  void enqueue_discovered_references(uint no_of_gc_workers);
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   669
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   670
public:
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   671
10671
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   672
  G1MonitoringSupport* g1mm() {
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   673
    assert(_g1mm != NULL, "should have been initialized");
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   674
    return _g1mm;
431ff8629f97 7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents: 10670
diff changeset
   675
  }
9338
05ee447bd420 6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents: 9334
diff changeset
   676
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   677
  // 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
   678
  // 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
   679
  // false otherwise.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   680
  // (Rounds up to a HeapRegion boundary.)
8103
65eafe3fb3c7 6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents: 8072
diff changeset
   681
  bool expand(size_t expand_bytes);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   682
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   683
  // Do anything common to GC's.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   684
  virtual void gc_prologue(bool full);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   685
  virtual void gc_epilogue(bool full);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   686
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   687
  // We register a region with the fast "in collection set" test. We
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   688
  // simply set to true the array slot corresponding to this region.
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   689
  void register_region_with_in_cset_fast_test(HeapRegion* r) {
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   690
    assert(_in_cset_fast_test_base != NULL, "sanity");
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   691
    assert(r->in_collection_set(), "invariant");
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   692
    uint index = r->hrs_index();
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   693
    assert(index < _in_cset_fast_test_length, "invariant");
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   694
    assert(!_in_cset_fast_test_base[index], "invariant");
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   695
    _in_cset_fast_test_base[index] = true;
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   696
  }
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   697
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   698
  // This is a fast test on whether a reference points into the
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   699
  // collection set or not. It does not assume that the reference
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   700
  // points into the heap; if it doesn't, it will return false.
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   701
  bool in_cset_fast_test(oop obj) {
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   702
    assert(_in_cset_fast_test != NULL, "sanity");
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   703
    if (_g1_committed.contains((HeapWord*) obj)) {
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   704
      // no need to subtract the bottom of the heap from obj,
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   705
      // _in_cset_fast_test is biased
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   706
      uintx index = (uintx) obj >> HeapRegion::LogOfHRGrainBytes;
1902
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   707
      bool ret = _in_cset_fast_test[index];
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   708
      // let's make sure the result is consistent with what the slower
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   709
      // test returns
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   710
      assert( ret || !obj_in_cs(obj), "sanity");
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   711
      assert(!ret ||  obj_in_cs(obj), "sanity");
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   712
      return ret;
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   713
    } else {
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   714
      return false;
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   715
    }
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   716
  }
bf5f0a3beffe 6484956: G1: improve evacuation pause efficiency
tonyp
parents: 1895
diff changeset
   717
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   718
  void clear_cset_fast_test() {
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   719
    assert(_in_cset_fast_test_base != NULL, "sanity");
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   720
    memset(_in_cset_fast_test_base, false,
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
   721
           (size_t) _in_cset_fast_test_length * sizeof(bool));
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   722
  }
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   723
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   724
  // 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
   725
  // 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
   726
  void increment_old_marking_cycles_started();
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   727
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   728
  // 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
   729
  // 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
   730
  // 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
   731
  // 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
   732
  // 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
   733
  // 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
   734
  // 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
   735
  // 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
   736
  // 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
   737
  // 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
   738
  // 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
   739
  // 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
   740
  // 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
   741
  // +ExplicitGCInvokesConcurrent).
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   742
  void increment_old_marking_cycles_completed(bool concurrent);
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   743
12934
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   744
  unsigned int old_marking_cycles_completed() {
f9bc0e664918 7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents: 12381
diff changeset
   745
    return _old_marking_cycles_completed;
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   746
  }
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5891
diff changeset
   747
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   748
  void register_concurrent_cycle_start(jlong start_time);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   749
  void register_concurrent_cycle_end();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   750
  void trace_heap_after_concurrent_cycle();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   751
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   752
  G1YCType yc_type();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   753
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   754
  G1HRPrinter* hr_printer() { return &_hr_printer; }
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 10000
diff changeset
   755
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   756
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   757
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   758
  // 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
   759
  // (Rounds down to a HeapRegion boundary.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   760
  virtual void shrink(size_t expand_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   761
  void shrink_helper(size_t expand_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   762
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   763
  #if TASKQUEUE_STATS
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   764
  static void print_taskqueue_stats_hdr(outputStream* const st = gclog_or_tty);
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   765
  void print_taskqueue_stats(outputStream* const st = gclog_or_tty) const;
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   766
  void reset_taskqueue_stats();
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   767
  #endif // TASKQUEUE_STATS
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
   768
7398
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   769
  // Schedule the VM operation that will do an evacuation pause to
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   770
  // satisfy an allocation request of word_size. *succeeded will
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   771
  // return whether the VM operation was successful (it did do an
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   772
  // 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
   773
  // locker was active). Given that we should not be holding the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   774
  // Heap_lock when we enter this method, we will pass the
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   775
  // gc_count_before (i.e., total_collections()) as a parameter since
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   776
  // 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
   777
  // methods that call do_collection_pause() release the Heap_lock
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   778
  // 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
   779
  HeapWord* do_collection_pause(size_t         word_size,
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   780
                                unsigned int   gc_count_before,
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   781
                                bool*          succeeded,
60e5c7cafdca 8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents: 19339
diff changeset
   782
                                GCCause::Cause gc_cause);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   783
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   784
  // 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
   785
  // 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
   786
  // to the GC locker being active, true otherwise
e4aa6d9bda09 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 7397
diff changeset
   787
  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
   788
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   789
  // Actually do the work of evacuating the collection set.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   790
  void evacuate_collection_set(EvacuationInfo& evacuation_info);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   791
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   792
  // The g1 remembered set of the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   793
  G1RemSet* _g1_rem_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   794
  // And it's mod ref barrier set, used to track updates for the above.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   795
  ModRefBarrierSet* _mr_bs;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   796
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   797
  // 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
   798
  // concurrently after the collection.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   799
  DirtyCardQueueSet _dirty_card_queue_set;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
   800
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   801
  // The closure used to refine a single card.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   802
  RefineCardTableEntryClosure* _refine_cte_cl;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   803
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   804
  // A function to check the consistency of dirty card logs.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   805
  void check_ct_logs_at_safepoint();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   806
6247
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   807
  // A DirtyCardQueueSet that is used to hold cards that contain
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   808
  // references into the current collection set. This is used to
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   809
  // update the remembered sets of the regions in the collection
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   810
  // set in the event of an evacuation failure.
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   811
  DirtyCardQueueSet _into_cset_dirty_card_queue_set;
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
   812
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   813
  // After a collection pause, make the regions in the CS into free
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   814
  // regions.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   815
  void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   816
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   817
  // 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
   818
  // statistics or updating free lists.
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   819
  void abandon_collection_set(HeapRegion* cs_head);
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
   820
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   821
  // Applies "scan_non_heap_roots" to roots outside the heap,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   822
  // "scan_rs" to roots inside the heap (having done "set_region" to
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   823
  // indicate the region in which the root resides),
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   824
  // and does "scan_metadata" If "scan_rs" is
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   825
  // NULL, then this step is skipped.  The "worker_i"
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   826
  // param is for use with parallel roots processing, and should be
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   827
  // the "i" of the calling parallel worker thread's work(i) function.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   828
  // In the sequential case this param will be ignored.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   829
  void g1_process_strong_roots(bool is_scavenging,
11754
b003db88c6d6 7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents: 11583
diff changeset
   830
                               ScanningOption so,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   831
                               OopClosure* scan_non_heap_roots,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   832
                               OopsInHeapRegionClosure* scan_rs,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
   833
                               G1KlassScanClosure* scan_klasses,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   834
                               int worker_i);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   835
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   836
  // Apply "blk" to all the weak roots of the system.  These include
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   837
  // JNI weak roots, the code cache, system dictionary, symbol table,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   838
  // string table, and referents of reachable weak refs.
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
   839
  void g1_process_weak_roots(OopClosure* root_closure);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   840
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   841
  // Frees a non-humongous region by initializing its contents and
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   842
  // adding it to the free list that's passed as a parameter (this is
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   843
  // usually a local list which will be appended to the master free
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   844
  // list later). The used bytes of freed regions are accumulated in
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   845
  // pre_used. If par is true, the region's RSet will not be freed
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   846
  // up. The assumption is that this will be done later.
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   847
  void free_region(HeapRegion* hr,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   848
                   size_t* pre_used,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   849
                   FreeRegionList* free_list,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   850
                   bool par);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   851
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   852
  // Frees a humongous region by collapsing it into individual regions
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   853
  // and calling free_region() for each of them. The freed regions
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   854
  // will be added to the free list that's passed as a parameter (this
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   855
  // is usually a local list which will be appended to the master free
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   856
  // list later). The used bytes of freed regions are accumulated in
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   857
  // pre_used. If par is true, the region's RSet will not be freed
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
   858
  // up. The assumption is that this will be done later.
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   859
  void free_humongous_region(HeapRegion* hr,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   860
                             size_t* pre_used,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   861
                             FreeRegionList* free_list,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   862
                             HumongousRegionSet* humongous_proxy_set,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
   863
                             bool par);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   864
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   865
  // Notifies all the necessary spaces that the committed space has
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   866
  // been updated (either expanded or shrunk). It should be called
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   867
  // after _g1_storage is updated.
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   868
  void update_committed_space(HeapWord* old_end, HeapWord* new_end);
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
   869
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   870
  // The concurrent marker (and the thread it runs in.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   871
  ConcurrentMark* _cm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   872
  ConcurrentMarkThread* _cmThread;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   873
  bool _mark_in_progress;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   874
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   875
  // The concurrent refiner.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   876
  ConcurrentG1Refine* _cg1r;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   877
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   878
  // The parallel task queues
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   879
  RefToScanQueueSet *_task_queues;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   880
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   881
  // True iff a evacuation has failed in the current collection.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   882
  bool _evacuation_failed;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   883
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   884
  EvacuationFailedInfo* _evacuation_failed_info_array;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   885
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   886
  // Failed evacuations cause some logical from-space objects to have
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   887
  // forwarding pointers to themselves.  Reset them.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   888
  void remove_self_forwarding_pointers();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   889
15608
a1fd1fc60c7d 8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents: 13926
diff changeset
   890
  // Together, these store an object with a preserved mark, and its mark value.
a1fd1fc60c7d 8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents: 13926
diff changeset
   891
  Stack<oop, mtGC>     _objs_with_preserved_marks;
a1fd1fc60c7d 8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents: 13926
diff changeset
   892
  Stack<markOop, mtGC> _preserved_marks_of_objs;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   893
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   894
  // 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
   895
  // word being overwritten with a self-forwarding-pointer.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   896
  void preserve_mark_if_necessary(oop obj, markOop m);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   897
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   898
  // The stack of evac-failure objects left to be scanned.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   899
  GrowableArray<oop>*    _evac_failure_scan_stack;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   900
  // The closure to apply to evac-failure objects.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   901
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   902
  OopsInHeapRegionClosure* _evac_failure_closure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   903
  // Set the field above.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   904
  void
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   905
  set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_closure) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   906
    _evac_failure_closure = evac_failure_closure;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   907
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   908
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   909
  // Push "obj" on the scan stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   910
  void push_on_evac_failure_scan_stack(oop obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   911
  // Process scan stack entries until the stack is empty.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   912
  void drain_evac_failure_scan_stack();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   913
  // True iff an invocation of "drain_scan_stack" is in progress; to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   914
  // prevent unnecessary recursion.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   915
  bool _drain_in_progress;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   916
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   917
  // Do any necessary initialization for evacuation-failure handling.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   918
  // "cl" is the closure that will be used to process evac-failure
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   919
  // objects.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   920
  void init_for_evac_failure(OopsInHeapRegionClosure* cl);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   921
  // Do any necessary cleanup for evacuation-failure handling data
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   922
  // structures.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   923
  void finalize_for_evac_failure();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   924
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   925
  // An attempt to evacuate "obj" has failed; take necessary steps.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   926
  oop handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state, oop obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   927
  void handle_evacuation_failure_common(oop obj, markOop m);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   928
13517
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   929
#ifndef PRODUCT
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   930
  // Support for forcing evacuation failures. Analogous to
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   931
  // PromotionFailureALot for the other collectors.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   932
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   933
  // Records whether G1EvacuationFailureALot should be in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   934
  // for the current GC
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   935
  bool _evacuation_failure_alot_for_current_gc;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   936
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   937
  // 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
   938
  // determining whether G1EvaucationFailureALot is in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   939
  // for the current GC.
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   940
  size_t _evacuation_failure_alot_gc_number;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   941
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   942
  // 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
   943
  volatile size_t _evacuation_failure_alot_count;
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   944
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   945
  // Set whether G1EvacuationFailureALot should be in effect
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   946
  // 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
   947
  // command line flags are set);
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   948
  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
   949
                                                  bool during_initial_mark,
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   950
                                                  bool during_marking);
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   951
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   952
  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
   953
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   954
  // 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
   955
  inline bool evacuation_should_fail();
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   956
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   957
  // Reset the G1EvacuationFailureALot counters.  Should be called at
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   958
  // 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
   959
  inline void reset_evacuation_should_fail();
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   960
#endif // !PRODUCT
f158a0c702d4 7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents: 13516
diff changeset
   961
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   962
  // ("Weak") Reference processing support.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   963
  //
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
   964
  // G1 has 2 instances of the reference processor class. One
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   965
  // (_ref_processor_cm) handles reference object discovery
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   966
  // and subsequent processing during concurrent marking cycles.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   967
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   968
  // The other (_ref_processor_stw) handles reference object
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   969
  // discovery and processing during full GCs and incremental
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   970
  // evacuation pauses.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   971
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   972
  // During an incremental pause, reference discovery will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   973
  // temporarily disabled for _ref_processor_cm and will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   974
  // enabled for _ref_processor_stw. At the end of the evacuation
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   975
  // pause references discovered by _ref_processor_stw will be
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   976
  // processed and discovery will be disabled. The previous
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   977
  // setting for reference object discovery for _ref_processor_cm
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   978
  // will be re-instated.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   979
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   980
  // At the start of marking:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   981
  //  * Discovery by the CM ref processor is verified to be inactive
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   982
  //    and it's discovered lists are empty.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   983
  //  * Discovery by the CM ref processor is then enabled.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   984
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   985
  // At the end of marking:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   986
  //  * Any references on the CM ref processor's discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   987
  //    lists are processed (possibly MT).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   988
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   989
  // At the start of full GC we:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   990
  //  * Disable discovery by the CM ref processor and
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   991
  //    empty CM ref processor's discovered lists
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   992
  //    (without processing any entries).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   993
  //  * Verify that the STW ref processor is inactive and it's
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   994
  //    discovered lists are empty.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   995
  //  * Temporarily set STW ref processor discovery as single threaded.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   996
  //  * Temporarily clear the STW ref processor's _is_alive_non_header
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   997
  //    field.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   998
  //  * Finally enable discovery by the STW ref processor.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
   999
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1000
  // The STW ref processor is used to record any discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1001
  // references during the full GC.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1002
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1003
  // At the end of a full GC we:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1004
  //  * Enqueue any reference objects discovered by the STW ref processor
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1005
  //    that have non-live referents. This has the side-effect of
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1006
  //    making the STW ref processor inactive by disabling discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1007
  //  * Verify that the CM ref processor is still inactive
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1008
  //    and no references have been placed on it's discovered
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1009
  //    lists (also checked as a precondition during initial marking).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1010
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1011
  // The (stw) reference processor...
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1012
  ReferenceProcessor* _ref_processor_stw;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1013
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1014
  STWGCTimer* _gc_timer_stw;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1015
  ConcurrentGCTimer* _gc_timer_cm;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1016
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1017
  G1OldTracer* _gc_tracer_cm;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1018
  G1NewTracer* _gc_tracer_stw;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1019
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1020
  // During reference object discovery, the _is_alive_non_header
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1021
  // closure (if non-null) is applied to the referent object to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1022
  // determine whether the referent is live. If so then the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1023
  // reference object does not need to be 'discovered' and can
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1024
  // 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
  1025
  // the number of 'discovered' reference objects that need to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1026
  // be processed.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1027
  //
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1028
  // Instance of the is_alive closure for embedding into the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1029
  // STW reference processor as the _is_alive_non_header field.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1030
  // Supplying a value for the _is_alive_non_header field is
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1031
  // optional but doing so prevents unnecessary additions to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1032
  // the discovered lists during reference discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1033
  G1STWIsAliveClosure _is_alive_closure_stw;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1034
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1035
  // The (concurrent marking) reference processor...
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1036
  ReferenceProcessor* _ref_processor_cm;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1037
7657
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7455
diff changeset
  1038
  // Instance of the concurrent mark is_alive closure for embedding
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1039
  // into the Concurrent Marking reference processor as the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1040
  // _is_alive_non_header field. Supplying a value for the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1041
  // _is_alive_non_header field is optional but doing so prevents
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1042
  // unnecessary additions to the discovered lists during reference
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1043
  // discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1044
  G1CMIsAliveClosure _is_alive_closure_cm;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1045
11248
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1046
  // Cache used by G1CollectedHeap::start_cset_region_for_worker().
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1047
  HeapRegion** _worker_cset_start_region;
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1048
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1049
  // Time stamp to validate the regions recorded in the cache
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1050
  // used by G1CollectedHeap::start_cset_region_for_worker().
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1051
  // The heap region entry for a given worker is valid iff
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1052
  // the associated time stamp value matches the current value
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1053
  // of G1CollectedHeap::_gc_time_stamp.
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1054
  unsigned int* _worker_cset_start_region_time_stamp;
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1055
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1056
  enum G1H_process_strong_roots_tasks {
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  1057
    G1H_PS_filter_satb_buffers,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1058
    G1H_PS_refProcessor_oops_do,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1059
    // Leave this one last.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1060
    G1H_PS_NumElements
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1061
  };
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1062
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1063
  SubTasksDone* _process_strong_tasks;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1064
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1065
  volatile bool _free_regions_coming;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1066
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1067
public:
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6260
diff changeset
  1068
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6260
diff changeset
  1069
  SubTasksDone* process_strong_tasks() { return _process_strong_tasks; }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6260
diff changeset
  1070
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1071
  void set_refine_cte_cl_concurrency(bool concurrent);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1072
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  1073
  RefToScanQueue *task_queue(int i) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1074
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2009
diff changeset
  1075
  // 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
  1076
  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
  1077
6247
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1078
  // A DirtyCardQueueSet that is used to hold cards that contain
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1079
  // references into the current collection set. This is used to
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1080
  // update the remembered sets of the regions in the collection
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1081
  // set in the event of an evacuation failure.
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1082
  DirtyCardQueueSet& into_cset_dirty_card_queue_set()
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1083
        { return _into_cset_dirty_card_queue_set; }
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1084
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1085
  // Create a G1CollectedHeap with the specified policy.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1086
  // Must call the initialize method afterwards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1087
  // May not return if something goes wrong.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1088
  G1CollectedHeap(G1CollectorPolicy* policy);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1089
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1090
  // 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
  1091
  // maximum sizes and remembered and barrier sets
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1092
  // specified by the policy object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1093
  jint initialize();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1094
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19549
diff changeset
  1095
  // 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
  1096
  static size_t conservative_max_heap_alignment();
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19549
diff changeset
  1097
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1098
  // Initialize weak reference processing.
7657
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7455
diff changeset
  1099
  virtual void ref_processing_init();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1100
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11248
diff changeset
  1101
  void set_par_threads(uint t) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1102
    SharedHeap::set_par_threads(t);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1103
    // Done in SharedHeap but oddly there are
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1104
    // two _process_strong_tasks's in a G1CollectedHeap
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1105
    // so do it here too.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1106
    _process_strong_tasks->set_n_threads(t);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1107
  }
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1108
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1109
  // Set _n_par_threads according to a policy TBD.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1110
  void set_par_threads();
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1111
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11169
diff changeset
  1112
  void set_n_termination(int t) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6260
diff changeset
  1113
    _process_strong_tasks->set_n_threads(t);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1114
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1115
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1116
  virtual CollectedHeap::Name kind() const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1117
    return CollectedHeap::G1CollectedHeap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1118
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1119
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1120
  // The current policy object for the collector.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1121
  G1CollectorPolicy* g1_policy() const { return _g1_policy; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1122
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1123
  virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) g1_policy(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1124
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1125
  // Adaptive size policy.  No such thing for g1.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1126
  virtual AdaptiveSizePolicy* size_policy() { return NULL; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1127
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1128
  // The rem set and barrier set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1129
  G1RemSet* g1_rem_set() const { return _g1_rem_set; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1130
  ModRefBarrierSet* mr_bs() const { return _mr_bs; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1131
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1132
  unsigned get_gc_time_stamp() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1133
    return _gc_time_stamp;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1134
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1135
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1136
  void reset_gc_time_stamp() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1137
    _gc_time_stamp = 0;
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
  1138
    OrderAccess::fence();
11248
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1139
    // Clear the cached CSet starting regions and time stamps.
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1140
    // Their validity is dependent on the GC timestamp.
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1141
    clear_cset_start_regions();
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
  1142
  }
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
  1143
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1144
  void check_gc_time_stamps() PRODUCT_RETURN;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1145
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
  1146
  void increment_gc_time_stamp() {
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
  1147
    ++_gc_time_stamp;
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
  1148
    OrderAccess::fence();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1149
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1150
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1151
  // 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
  1152
  // also reset the GC timestamp of its corresponding
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1153
  // continues humongous regions too.
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1154
  void reset_gc_time_stamps(HeapRegion* hr);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1155
6247
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1156
  void iterate_dirty_card_closure(CardTableEntryClosure* cl,
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1157
                                  DirtyCardQueue* into_cset_dcq,
00e5cc407d03 6814437: G1: remove the _new_refs array
johnc
parents: 6058
diff changeset
  1158
                                  bool concurrent, int worker_i);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1159
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1160
  // The shared block offset table array.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1161
  G1BlockOffsetSharedArray* bot_shared() const { return _bot_shared; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1162
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1163
  // Reference Processing accessors
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1164
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1165
  // The STW reference processor....
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1166
  ReferenceProcessor* ref_processor_stw() const { return _ref_processor_stw; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1167
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1168
  // The Concurrent Marking reference processor...
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10664
diff changeset
  1169
  ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1170
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1171
  ConcurrentGCTimer* gc_timer_cm() const { return _gc_timer_cm; }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1172
  G1OldTracer* gc_tracer_cm() const { return _gc_tracer_cm; }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1173
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1174
  virtual size_t capacity() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1175
  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
  1176
  // 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
  1177
  // 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
  1178
  size_t used_unlocked() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1179
  size_t recalculate_used() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1180
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1181
  // These virtual functions do the actual allocation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1182
  // Some heaps may offer a contiguous region for shared non-blocking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1183
  // 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
  1184
  // end fields defining the extent of the contiguous allocation region.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1185
  // But G1CollectedHeap doesn't yet support this.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1186
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1187
  // Return an estimate of the maximum allocation that could be performed
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1188
  // without triggering any collection or expansion activity.  In a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1189
  // generational collector, for example, this is probably the largest
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1190
  // allocation that could be supported (without expansion) in the youngest
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1191
  // generation.  It is "unsafe" because no locks are taken; the result
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1192
  // should be treated as an approximation, not a guarantee, for use in
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1193
  // heuristic resizing decisions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1194
  virtual size_t unsafe_max_alloc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1195
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1196
  virtual bool is_maximal_no_gc() const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1197
    return _g1_storage.uncommitted_size() == 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1198
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1199
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1200
  // The total number of regions in the heap.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1201
  uint n_regions() { return _hrs.length(); }
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1202
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1203
  // The max number of regions in the heap.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1204
  uint max_regions() { return _hrs.max_length(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1205
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1206
  // The number of regions that are completely free.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1207
  uint free_regions() { return _free_list.length(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1208
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1209
  // The number of regions that are not completely free.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1210
  uint used_regions() { return n_regions() - free_regions(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1211
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1212
  // The number of regions available for "regular" expansion.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1213
  uint expansion_regions() { return _expansion_regions; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1214
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1215
  // Factory method for HeapRegion instances. It will return NULL if
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1216
  // the allocation fails.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1217
  HeapRegion* new_heap_region(uint hrs_index, HeapWord* bottom);
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1218
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9338
diff changeset
  1219
  void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN;
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9338
diff changeset
  1220
  void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN;
8928
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
  1221
  void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN;
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
  1222
  void verify_dirty_young_regions() PRODUCT_RETURN;
e5c53268bef5 7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents: 8927
diff changeset
  1223
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1224
  // verify_region_sets() performs verification over the region
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1225
  // lists. It will be compiled in the product code to be used when
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1226
  // necessary (i.e., during heap verification).
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1227
  void verify_region_sets();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1228
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1229
  // verify_region_sets_optional() is planted in the code for
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1230
  // list verification in non-product builds (and it can be enabled in
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1231
  // product builds by defining HEAP_REGION_SET_FORCE_VERIFY to be 1).
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1232
#if HEAP_REGION_SET_FORCE_VERIFY
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1233
  void verify_region_sets_optional() {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1234
    verify_region_sets();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1235
  }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1236
#else // HEAP_REGION_SET_FORCE_VERIFY
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1237
  void verify_region_sets_optional() { }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1238
#endif // HEAP_REGION_SET_FORCE_VERIFY
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1239
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1240
#ifdef ASSERT
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1241
  bool is_on_master_free_list(HeapRegion* hr) {
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1242
    return hr->containing_set() == &_free_list;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1243
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1244
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1245
  bool is_in_humongous_set(HeapRegion* hr) {
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1246
    return hr->containing_set() == &_humongous_set;
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1247
  }
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1248
#endif // ASSERT
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1249
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1250
  // Wrapper for the region list operations that can be called from
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1251
  // methods outside this class.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1252
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1253
  void secondary_free_list_add_as_tail(FreeRegionList* list) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1254
    _secondary_free_list.add_as_tail(list);
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1255
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1256
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1257
  void append_secondary_free_list() {
8927
461fa7ee5254 7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents: 8680
diff changeset
  1258
    _free_list.add_as_head(&_secondary_free_list);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1259
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1260
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1261
  void append_secondary_free_list_if_not_empty_with_lock() {
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1262
    // If the secondary free list looks empty there's no reason to
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8485
diff changeset
  1263
    // take the lock and then try to append it.
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1264
    if (!_secondary_free_list.is_empty()) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1265
      MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1266
      append_secondary_free_list();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1267
    }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1268
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1269
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1270
  void old_set_remove(HeapRegion* hr) {
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1271
    _old_set.remove(hr);
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1272
  }
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1273
11576
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1274
  size_t non_young_capacity_bytes() {
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1275
    return _old_set.total_capacity_bytes() + _humongous_set.total_capacity_bytes();
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1276
  }
e0bef5ca4602 6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents: 11455
diff changeset
  1277
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1278
  void set_free_regions_coming();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1279
  void reset_free_regions_coming();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1280
  bool free_regions_coming() { return _free_regions_coming; }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1281
  void wait_while_free_regions_coming();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1282
11756
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1283
  // 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
  1284
  // old GC alloc region.
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1285
  bool is_old_gc_alloc_region(HeapRegion* hr) {
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1286
    return hr == _retained_old_gc_alloc_region;
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1287
  }
28b6fe22e43d 7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents: 11754
diff changeset
  1288
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1289
  // Perform a collection of the heap; intended for use in implementing
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1290
  // "System.gc".  This probably implies as full a collection as the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1291
  // "CollectedHeap" supports.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1292
  virtual void collect(GCCause::Cause cause);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1293
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1294
  // The same as above but assume that the caller holds the Heap_lock.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1295
  void collect_locked(GCCause::Cause cause);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1296
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1297
  // 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
  1298
  bool evacuation_failed() { return _evacuation_failed; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1299
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1300
  // It will free a region if it has allocated objects in it that are
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1301
  // all dead. It calls either free_region() or
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1302
  // free_humongous_region() depending on the type of the region that
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1303
  // is passed to it.
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1304
  void free_region_if_empty(HeapRegion* hr,
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1305
                            size_t* pre_used,
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1306
                            FreeRegionList* free_list,
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1307
                            OldRegionSet* old_proxy_set,
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1308
                            HumongousRegionSet* humongous_proxy_set,
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1309
                            HRRSCleanupTask* hrrs_cleanup_task,
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1310
                            bool par);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1311
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1312
  // It appends the free list to the master free list and updates the
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1313
  // master humongous list according to the contents of the proxy
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1314
  // list. It also adjusts the total used bytes according to pre_used
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1315
  // (if par is true, it will do so by taking the ParGCRareEvent_lock).
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1316
  void update_sets_after_freeing_regions(size_t pre_used,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1317
                                       FreeRegionList* free_list,
10996
b9d07748e5b3 7092309: G1: introduce old region set
tonyp
parents: 10679
diff changeset
  1318
                                       OldRegionSet* old_proxy_set,
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1319
                                       HumongousRegionSet* humongous_proxy_set,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7905
diff changeset
  1320
                                       bool par);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1321
11247
d6faa02b3802 7121373: Clean up CollectedHeap::is_in
stefank
parents: 11176
diff changeset
  1322
  // Returns "TRUE" iff "p" points into the committed areas of the heap.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1323
  virtual bool is_in(const void* p) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1324
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1325
  // Return "TRUE" iff the given object address is within the collection
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1326
  // set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1327
  inline bool obj_in_cs(oop obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1328
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1329
  // 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
  1330
  // region of g1.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1331
  bool is_in_g1_reserved(const void* p) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1332
    return _g1_reserved.contains(p);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1333
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1334
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1335
  // 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
  1336
  // reserved for the heap
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1337
  MemRegion g1_reserved() {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1338
    return _g1_reserved;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1339
  }
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1340
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8928
diff changeset
  1341
  // Returns a MemRegion that corresponds to the space that has been
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1342
  // committed in the heap
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1343
  MemRegion g1_committed() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1344
    return _g1_committed;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1345
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1346
8485
e84ccd8664ba 7022200: G1: optimized build broken
johnc
parents: 8103
diff changeset
  1347
  virtual bool is_in_closed_subset(const void* p) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1348
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1349
  // This resets the card table to all zeros.  It is used after
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1350
  // a collection pause which used the card table to claim cards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1351
  void cleanUpCardTable();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1352
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1353
  // Iteration functions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1354
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1355
  // Iterate over all the ref-containing fields of all objects, calling
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1356
  // "cl.do_oop" on each.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1357
  virtual void oop_iterate(ExtendedOopClosure* cl);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1358
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1359
  // Same as above, restricted to a memory region.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1360
  void oop_iterate(MemRegion mr, ExtendedOopClosure* cl);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1361
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1362
  // 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
  1363
  virtual void object_iterate(ObjectClosure* cl);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1364
2345
3098a48a7240 6822263: G1: JVMTI heap iteration fails
iveresov
parents: 2344
diff changeset
  1365
  virtual void safe_object_iterate(ObjectClosure* cl) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1366
    object_iterate(cl);
2345
3098a48a7240 6822263: G1: JVMTI heap iteration fails
iveresov
parents: 2344
diff changeset
  1367
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1368
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1369
  // Iterate over all spaces in use in the heap, in ascending address order.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1370
  virtual void space_iterate(SpaceClosure* cl);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1371
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1372
  // Iterate over heap regions, in address order, terminating the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1373
  // iteration early if the "doHeapRegion" method returns "true".
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1374
  void heap_region_iterate(HeapRegionClosure* blk) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1375
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1376
  // Return the region with the given index. It assumes the index is valid.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1377
  HeapRegion* region_at(uint index) const { return _hrs.at(index); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1378
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1379
  // Divide the heap region sequence into "chunks" of some size (the number
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1380
  // of regions divided by the number of parallel threads times some
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1381
  // overpartition factor, currently 4).  Assumes that this will be called
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1382
  // in parallel by ParallelGCThreads worker threads with discinct worker
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1383
  // ids in the range [0..max(ParallelGCThreads-1, 1)], that all parallel
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1384
  // calls will use the same "claim_value", and that that claim value is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1385
  // different from the claim_value of any heap region before the start of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1386
  // the iteration.  Applies "blk->doHeapRegion" to each of the regions, by
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1387
  // attempting to claim the first region in each chunk, and, if
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1388
  // successful, applying the closure to each region in the chunk (and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1389
  // setting the claim value of the second and subsequent regions of the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1390
  // chunk.)  For now requires that "doHeapRegion" always returns "false",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1391
  // i.e., that a closure never attempt to abort a traversal.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1392
  void heap_region_par_iterate_chunked(HeapRegionClosure* blk,
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11248
diff changeset
  1393
                                       uint worker,
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11248
diff changeset
  1394
                                       uint no_of_par_workers,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1395
                                       jint claim_value);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1396
1422
9af8f4023912 6752248: G1: introduce parallel heap verification
tonyp
parents: 1387
diff changeset
  1397
  // It resets all the region claim values to the default.
9af8f4023912 6752248: G1: introduce parallel heap verification
tonyp
parents: 1387
diff changeset
  1398
  void reset_heap_region_claim_values();
9af8f4023912 6752248: G1: introduce parallel heap verification
tonyp
parents: 1387
diff changeset
  1399
11451
9c9aa4d85660 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents: 11449
diff changeset
  1400
  // Resets the claim values of regions in the current
9c9aa4d85660 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents: 11449
diff changeset
  1401
  // collection set to the default.
9c9aa4d85660 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents: 11449
diff changeset
  1402
  void reset_cset_heap_region_claim_values();
9c9aa4d85660 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents: 11449
diff changeset
  1403
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1385
diff changeset
  1404
#ifdef ASSERT
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1385
diff changeset
  1405
  bool check_heap_region_claim_values(jint claim_value);
11176
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1406
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1407
  // Same as the routine above but only checks regions in the
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1408
  // current collection set.
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1409
  bool check_cset_heap_region_claim_values(jint claim_value);
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1385
diff changeset
  1410
#endif // ASSERT
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1385
diff changeset
  1411
11248
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1412
  // Clear the cached cset start regions and (more importantly)
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1413
  // the time stamps. Called when we reset the GC time stamp.
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1414
  void clear_cset_start_regions();
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1415
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1416
  // Given the id of a worker, obtain or calculate a suitable
5ff61b0fdf3d 7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents: 11247
diff changeset
  1417
  // starting region for iterating over the current collection set.
11176
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1418
  HeapRegion* start_cset_region_for_worker(int worker_i);
9bb1ddd8da51 7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents: 11174
diff changeset
  1419
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1420
  // This is a convenience method that is used by the
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1421
  // HeapRegionIterator classes to calculate the starting region for
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1422
  // each worker so that they do not all start from the same region.
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1423
  HeapRegion* start_region_for_worker(uint worker_i, uint no_of_par_workers);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1424
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1425
  // Iterate over the regions (if any) in the current collection set.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1426
  void collection_set_iterate(HeapRegionClosure* blk);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1427
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1428
  // As above but starting from region r
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1429
  void collection_set_iterate_from(HeapRegion* r, HeapRegionClosure *blk);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1430
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1431
  // Returns the first (lowest address) compactible space in the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1432
  virtual CompactibleSpace* first_compactible_space();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1433
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1434
  // A CollectedHeap will contain some number of spaces.  This finds the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1435
  // space containing a given address, or else returns NULL.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1436
  virtual Space* space_containing(const void* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1437
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1438
  // A G1CollectedHeap will contain some number of heap regions.  This
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1439
  // finds the region containing a given address, or else returns NULL.
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1440
  template <class T>
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1441
  inline HeapRegion* heap_region_containing(const T addr) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1442
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1443
  // Like the above, but requires "addr" to be in the heap (to avoid a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1444
  // null-check), and unlike the above, may return an continuing humongous
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1445
  // region.
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1446
  template <class T>
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1447
  inline HeapRegion* heap_region_containing_raw(const T addr) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1448
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1449
  // 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
  1450
  // each address in the (reserved) heap is a member of exactly
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1451
  // 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
  1452
  // 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
  1453
  // block.  (Blocks may be of different sizes.)  Thus, blocks may
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1454
  // represent Java objects, or they might be free blocks in a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1455
  // 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
  1456
  // distinguishable and the size of each is determinable.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1457
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1458
  // 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
  1459
  // address "addr".  We say "blocks" instead of "object" since some heaps
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1460
  // 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
  1461
  // non-object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1462
  virtual HeapWord* block_start(const void* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1463
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1464
  // 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
  1465
  // "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
  1466
  // of the active area of the heap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1467
  virtual size_t block_size(const HeapWord* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1468
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1469
  // 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
  1470
  // the block is an object.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1471
  virtual bool block_is_obj(const HeapWord* addr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1472
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1473
  // Does this heap support heap inspection? (+PrintClassHistogram)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1474
  virtual bool supports_heap_inspection() const { return true; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1475
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1476
  // Section on thread-local allocation buffers (TLABs)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1477
  // See CollectedHeap for semantics.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1478
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1479
  virtual bool supports_tlab_allocation() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1480
  virtual size_t tlab_capacity(Thread* thr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1481
  virtual size_t unsafe_max_tlab_alloc(Thread* thr) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1482
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1483
  // Can a compiler initialize a new object without store barriers?
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1484
  // 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
  1485
  // 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
  1486
  // 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
  1487
  // 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
  1488
  // 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
  1489
  // 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
  1490
  // 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
  1491
  // 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
  1492
  // 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
  1493
  // 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
  1494
  // 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
  1495
  // See ReduceInitialCardMarks.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1496
  virtual bool can_elide_tlab_store_barriers() const {
10679
f598a613d73e 7005808: G1: re-enable ReduceInitialCardMarks for G1
brutisso
parents: 10671
diff changeset
  1497
    return true;
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1498
  }
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1499
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1500
  virtual bool card_mark_must_follow_store() const {
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1501
    return true;
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1502
  }
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4462
diff changeset
  1503
9989
305a76435cf1 7045330: G1: Simplify/fix the HeapRegionSeq class
tonyp
parents: 9987
diff changeset
  1504
  bool is_in_young(const oop obj) {
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1505
    HeapRegion* hr = heap_region_containing(obj);
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1506
    return hr != NULL && hr->is_young();
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1507
  }
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1508
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1509
#ifdef ASSERT
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1510
  virtual bool is_in_partial_collection(const void* p);
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1511
#endif
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1512
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1513
  virtual bool is_scavengable(const void* addr);
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9418
diff changeset
  1514
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1515
  // 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
  1516
  // 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
  1517
  // 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
  1518
  // 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
  1519
  // information for young gen objects.
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1520
  virtual bool can_elide_initializing_store_barrier(oop new_obj) {
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3697
diff changeset
  1521
    return is_in_young(new_obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1522
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1523
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1524
  // Returns "true" iff the given word_size is "very large".
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1525
  static bool isHumongous(size_t word_size) {
5078
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1526
    // Note this has to be strictly greater-than as the TLABs
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1527
    // are capped at the humongous thresold and we want to
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1528
    // 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
  1529
    // humongous and that we don't allocate a humongous
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1530
    // object in a TLAB.
e865c7385a24 6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents: 5076
diff changeset
  1531
    return word_size > _humongous_object_threshold_in_words;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1532
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1533
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1534
  // Update mod union table with the set of dirty cards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1535
  void updateModUnion();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1536
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1537
  // Set the mod union bits corresponding to the given memRegion.  Note
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1538
  // that this is always a safe operation, since it doesn't clear any
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1539
  // bits.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1540
  void markModUnionRange(MemRegion mr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1541
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1542
  // Records the fact that a marking phase is no longer in progress.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1543
  void set_marking_complete() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1544
    _mark_in_progress = false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1545
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1546
  void set_marking_started() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1547
    _mark_in_progress = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1548
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1549
  bool mark_in_progress() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1550
    return _mark_in_progress;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1551
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1552
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1553
  // Print the maximum heap capacity.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1554
  virtual size_t max_capacity() const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1555
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1556
  virtual jlong millis_since_last_gc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1557
10000
5bbb58b0dbb9 7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents: 9997
diff changeset
  1558
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1559
  // 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
  1560
  // asserted to be this type.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1561
  static G1CollectedHeap* heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1562
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1563
  void set_region_short_lived_locked(HeapRegion* hr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1564
  // add appropriate methods for any other surv rate groups
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1565
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
  1566
  YoungList* young_list() { return _young_list; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1567
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1568
  // debugging
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1569
  bool check_young_list_well_formed() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1570
    return _young_list->check_list_well_formed();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1571
  }
5350
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
  1572
cccf0925702e 6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents: 5347
diff changeset
  1573
  bool check_young_list_empty(bool check_heap,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1574
                              bool check_sample = true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1575
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1576
  // *** 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
  1577
  // many of these need to be public.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1578
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1579
  // The functions below are helper functions that a subclass of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1580
  // "CollectedHeap" can use in the implementation of its virtual
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1581
  // functions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1582
  // This performs a concurrent marking of the live objects in a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1583
  // bitmap off to the side.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1584
  void doConcurrentMark();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1585
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1586
  bool isMarkedPrev(oop obj) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1587
  bool isMarkedNext(oop obj) const;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1588
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1589
  // Determine if an object is dead, given the object and also
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1590
  // the region to which the object belongs. An object is dead
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1591
  // iff a) it was not allocated since the last mark and b) it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1592
  // is not marked.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1593
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1594
  bool is_obj_dead(const oop obj, const HeapRegion* hr) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1595
    return
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1596
      !hr->obj_allocated_since_prev_marking(obj) &&
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1597
      !isMarkedPrev(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1598
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1599
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1600
  // This function returns true when an object has been
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1601
  // around since the previous marking and hasn't yet
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1602
  // been marked during this marking.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1603
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1604
  bool is_obj_ill(const oop obj, const HeapRegion* hr) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1605
    return
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1606
      !hr->obj_allocated_since_next_marking(obj) &&
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1607
      !isMarkedNext(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1608
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1609
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1610
  // Determine if an object is dead, given only the object itself.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1611
  // This will find the region to which the object belongs and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1612
  // then call the region version of the same function.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1613
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1614
  // Added if it is NULL it isn't dead.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1615
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9989
diff changeset
  1616
  bool is_obj_dead(const oop obj) const {
3000
bbce6052b595 6850846: G1: extend G1 marking verification
tonyp
parents: 2996
diff changeset
  1617
    const HeapRegion* hr = heap_region_containing(obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1618
    if (hr == NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1619
      if (obj == NULL) return false;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1620
      else return true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1621
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1622
    else return is_obj_dead(obj, hr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1623
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1624
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9989
diff changeset
  1625
  bool is_obj_ill(const oop obj) const {
3000
bbce6052b595 6850846: G1: extend G1 marking verification
tonyp
parents: 2996
diff changeset
  1626
    const HeapRegion* hr = heap_region_containing(obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1627
    if (hr == NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13517
diff changeset
  1628
      if (obj == NULL) return false;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1629
      else return true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1630
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1631
    else return is_obj_ill(obj, hr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1632
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1633
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1634
  bool allocated_since_marking(oop obj, HeapRegion* hr, VerifyOption vo);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1635
  HeapWord* top_at_mark_start(HeapRegion* hr, VerifyOption vo);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1636
  bool is_marked(oop obj, VerifyOption vo);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1637
  const char* top_at_mark_start_str(VerifyOption vo);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1638
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1639
  ConcurrentMark* concurrent_mark() const { return _cm; }
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1640
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1641
  // Refinement
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1642
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1643
  ConcurrentG1Refine* concurrent_g1_refine() const { return _cg1r; }
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1644
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1645
  // The dirty cards region list is used to record a subset of regions
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1646
  // whose cards need clearing. The list if populated during the
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1647
  // remembered set scanning and drained during the card table
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1648
  // cleanup. Although the methods are reentrant, population/draining
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1649
  // phases must not overlap. For synchronization purposes the last
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1650
  // element on the list points to itself.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1651
  HeapRegion* _dirty_cards_region_list;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1652
  void push_dirty_cards_region(HeapRegion* hr);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1653
  HeapRegion* pop_dirty_cards_region();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1654
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1655
  // Optimized nmethod scanning support routines
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1656
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1657
  // Register the given nmethod with the G1 heap
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1658
  virtual void register_nmethod(nmethod* nm);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1659
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1660
  // Unregister the given nmethod from the G1 heap
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1661
  virtual void unregister_nmethod(nmethod* nm);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1662
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1663
  // Migrate the nmethods in the code root lists of the regions
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1664
  // in the collection set to regions in to-space. In the event
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1665
  // of an evacuation failure, nmethods that reference objects
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1666
  // that were not successfullly evacuated are not migrated.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1667
  void migrate_strong_code_roots();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1668
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1669
  // During an initial mark pause, mark all the code roots that
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1670
  // point into regions *not* in the collection set.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1671
  void mark_strong_code_roots(uint worker_id);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1672
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1673
  // Rebuild the stong code root lists for each region
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1674
  // after a full GC
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1675
  void rebuild_strong_code_roots();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1676
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1677
  // Verification
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1678
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1679
  // The following is just to alert the verification code
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1680
  // that a full collection has occurred and that the
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1681
  // remembered sets are no longer up to date.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1682
  bool _full_collection;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1683
  void set_full_collection() { _full_collection = true;}
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1684
  void clear_full_collection() {_full_collection = false;}
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1685
  bool full_collection() {return _full_collection;}
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1686
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1687
  // Perform any cleanup actions necessary before allowing a verification.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1688
  virtual void prepare_for_verify();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1689
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1690
  // Perform verification.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1691
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1692
  // vo == UsePrevMarking  -> use "prev" marking information,
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1693
  // vo == UseNextMarking -> use "next" marking information
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1694
  // vo == UseMarkWord    -> use the mark word in the object header
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1695
  //
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1696
  // NOTE: Only the "prev" marking information is guaranteed to be
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1697
  // consistent most of the time, so most calls to this should use
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1698
  // vo == UsePrevMarking.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1699
  // Currently, there is only one case where this is called with
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1700
  // vo == UseNextMarking, which is to verify the "next" marking
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1701
  // information at the end of remark.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1702
  // Currently there is only one place where this is called with
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1703
  // vo == UseMarkWord, which is to verify the marking during a
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1704
  // full GC.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1705
  void verify(bool silent, VerifyOption vo);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1706
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1707
  // Override; it uses the "prev" marking information
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1708
  virtual void verify(bool silent);
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1709
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1710
  // 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
  1711
  // appropriate method depending on value of the given VerifyOption
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1712
  // parameter. The values for that parameter, and their meanings,
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1713
  // are the same as those above.
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1714
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1715
  bool is_obj_dead_cond(const oop obj,
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1716
                        const HeapRegion* hr,
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1717
                        const VerifyOption vo) const {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1718
    switch (vo) {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1719
    case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj, hr);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1720
    case VerifyOption_G1UseNextMarking: return is_obj_ill(obj, hr);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1721
    case VerifyOption_G1UseMarkWord:    return !obj->is_gc_marked();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1722
    default:                            ShouldNotReachHere();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1723
    }
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1724
    return false; // keep some compilers happy
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1725
  }
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1726
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1727
  bool is_obj_dead_cond(const oop obj,
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1728
                        const VerifyOption vo) const {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1729
    switch (vo) {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1730
    case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1731
    case VerifyOption_G1UseNextMarking: return is_obj_ill(obj);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1732
    case VerifyOption_G1UseMarkWord:    return !obj->is_gc_marked();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1733
    default:                            ShouldNotReachHere();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1734
    }
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1735
    return false; // keep some compilers happy
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1736
  }
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1737
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1738
  // Printing
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13195
diff changeset
  1739
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1740
  virtual void print_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1741
  virtual void print_extended_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1742
  virtual void print_on_error(outputStream* st) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1743
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1744
  virtual void print_gc_threads_on(outputStream* st) const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1745
  virtual void gc_threads_do(ThreadClosure* tc) const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1746
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1747
  // Override
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1748
  void print_tracing_info() const;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1749
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1750
  // The following two methods are helpful for debugging RSet issues.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1751
  void print_cset_rsets() PRODUCT_RETURN;
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18687
diff changeset
  1752
  void print_all_rsets() PRODUCT_RETURN;
2883
406d1e6d1aa1 6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents: 2345
diff changeset
  1753
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1754
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1755
  void stop_conc_gc_threads();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1756
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1757
  size_t pending_card_num();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1758
  size_t cards_scanned();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1759
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1760
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1761
  size_t _max_heap_capacity;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1762
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1763
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1764
class G1ParGCAllocBuffer: public ParGCAllocBuffer {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1765
private:
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1766
  bool        _retired;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1767
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1768
public:
10495
d20531ba2b31 7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents: 10280
diff changeset
  1769
  G1ParGCAllocBuffer(size_t gclab_word_size);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1770
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  1771
  void set_buf(HeapWord* buf) {
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1772
    ParGCAllocBuffer::set_buf(buf);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1773
    _retired = false;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1774
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1775
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  1776
  void retire(bool end_of_gc, bool retain) {
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1777
    if (_retired)
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1778
      return;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1779
    ParGCAllocBuffer::retire(end_of_gc, retain);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1780
    _retired = true;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1781
  }
17856
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1782
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1783
  bool is_retired() {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1784
    return _retired;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1785
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1786
};
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1787
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1788
class G1ParGCAllocBufferContainer {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1789
protected:
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1790
  static int const _priority_max = 2;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1791
  G1ParGCAllocBuffer* _priority_buffer[_priority_max];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1792
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1793
public:
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1794
  G1ParGCAllocBufferContainer(size_t gclab_word_size) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1795
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1796
      _priority_buffer[pr] = new G1ParGCAllocBuffer(gclab_word_size);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1797
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1798
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1799
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1800
  ~G1ParGCAllocBufferContainer() {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1801
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1802
      assert(_priority_buffer[pr]->is_retired(), "alloc buffers should all retire at this point.");
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1803
      delete _priority_buffer[pr];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1804
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1805
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1806
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1807
  HeapWord* allocate(size_t word_sz) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1808
    HeapWord* obj;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1809
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1810
      obj = _priority_buffer[pr]->allocate(word_sz);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1811
      if (obj != NULL) return obj;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1812
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1813
    return obj;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1814
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1815
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1816
  bool contains(void* addr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1817
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1818
      if (_priority_buffer[pr]->contains(addr)) return true;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1819
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1820
    return false;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1821
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1822
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1823
  void undo_allocation(HeapWord* obj, size_t word_sz) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1824
    bool finish_undo;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1825
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1826
      if (_priority_buffer[pr]->contains(obj)) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1827
        _priority_buffer[pr]->undo_allocation(obj, word_sz);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1828
        finish_undo = true;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1829
      }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1830
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1831
    if (!finish_undo) ShouldNotReachHere();
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1832
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1833
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1834
  size_t words_remaining() {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1835
    size_t result = 0;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1836
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1837
      result += _priority_buffer[pr]->words_remaining();
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1838
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1839
    return result;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1840
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1841
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1842
  size_t words_remaining_in_retired_buffer() {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1843
    G1ParGCAllocBuffer* retired = _priority_buffer[0];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1844
    return retired->words_remaining();
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1845
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1846
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1847
  void flush_stats_and_retire(PLABStats* stats, bool end_of_gc, bool retain) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1848
    for (int pr = 0; pr < _priority_max; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1849
      _priority_buffer[pr]->flush_stats_and_retire(stats, end_of_gc, retain);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1850
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1851
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1852
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1853
  void update(bool end_of_gc, bool retain, HeapWord* buf, size_t word_sz) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1854
    G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1855
    retired_and_set->retire(end_of_gc, retain);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1856
    retired_and_set->set_buf(buf);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1857
    retired_and_set->set_word_size(word_sz);
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1858
    adjust_priority_order();
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1859
  }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1860
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1861
private:
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1862
  void adjust_priority_order() {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1863
    G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1864
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1865
    int last = _priority_max - 1;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1866
    for (int pr = 0; pr < last; ++pr) {
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1867
      _priority_buffer[pr] = _priority_buffer[pr + 1];
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1868
    }
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1869
    _priority_buffer[last] = retired_and_set;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1870
  }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1871
};
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1872
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1873
class G1ParScanThreadState : public StackObj {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1874
protected:
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1875
  G1CollectedHeap* _g1h;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1876
  RefToScanQueue*  _refs;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1877
  DirtyCardQueue   _dcq;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1878
  CardTableModRefBS* _ct_bs;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1879
  G1RemSet* _g1_rem;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1880
17856
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1881
  G1ParGCAllocBufferContainer  _surviving_alloc_buffer;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1882
  G1ParGCAllocBufferContainer  _tenured_alloc_buffer;
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1883
  G1ParGCAllocBufferContainer* _alloc_buffers[GCAllocPurposeCount];
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  1884
  ageTable            _age_table;
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1885
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1886
  size_t           _alloc_buffer_waste;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1887
  size_t           _undo_waste;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1888
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1889
  OopsInHeapRegionClosure*      _evac_failure_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1890
  G1ParScanHeapEvacClosure*     _evac_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1891
  G1ParScanPartialArrayClosure* _partial_scan_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1892
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17856
diff changeset
  1893
  int  _hash_seed;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11576
diff changeset
  1894
  uint _queue_num;
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1895
5891
59044ec3fca3 6946048: G1: improvements to +PrintGCDetails output
tonyp
parents: 5547
diff changeset
  1896
  size_t _term_attempts;
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1897
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1898
  double _start;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1899
  double _start_strong_roots;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1900
  double _strong_roots_time;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1901
  double _start_term;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1902
  double _term_time;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1903
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1904
  // Map from young-age-index (0 == not young, 1 is youngest) to
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1905
  // surviving words. base is what we get back from the malloc call
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1906
  size_t* _surviving_young_words_base;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1907
  // this points into the array, as we use the first few entries for padding
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1908
  size_t* _surviving_young_words;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1909
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  1910
#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1911
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1912
  void   add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1913
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1914
  void   add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1915
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1916
  DirtyCardQueue& dirty_card_queue()             { return _dcq;  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1917
  CardTableModRefBS* ctbs()                      { return _ct_bs; }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1918
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1919
  template <class T> void immediate_rs_update(HeapRegion* from, T* p, int tid) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1920
    if (!from->is_survivor()) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1921
      _g1_rem->par_write_ref(from, p, tid);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1922
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1923
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1924
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1925
  template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1926
    // If the new value of the field points to the same region or
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1927
    // is the to-space, we don't need to include it in the Rset updates.
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1928
    if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1929
      size_t card_index = ctbs()->index_for(p);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1930
      // If the card hasn't been added to the buffer, do it.
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1931
      if (ctbs()->mark_card_deferred(card_index)) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1932
        dirty_card_queue().enqueue((jbyte*)ctbs()->byte_for_index(card_index));
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1933
      }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1934
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1935
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1936
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1937
public:
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11576
diff changeset
  1938
  G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1939
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1940
  ~G1ParScanThreadState() {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12934
diff changeset
  1941
    FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1942
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1943
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1944
  RefToScanQueue*   refs()            { return _refs;             }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1945
  ageTable*         age_table()       { return &_age_table;       }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1946
17856
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1947
  G1ParGCAllocBufferContainer* alloc_buffer(GCAllocPurpose purpose) {
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  1948
    return _alloc_buffers[purpose];
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1949
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1950
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  1951
  size_t alloc_buffer_waste() const              { return _alloc_buffer_waste; }
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  1952
  size_t undo_waste() const                      { return _undo_waste; }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1953
6959
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1954
#ifdef ASSERT
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1955
  bool verify_ref(narrowOop* ref) const;
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1956
  bool verify_ref(oop* ref) const;
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1957
  bool verify_task(StarTask ref) const;
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1958
#endif // ASSERT
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1959
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1960
  template <class T> void push_on_queue(T* ref) {
6959
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  1961
    assert(verify_ref(ref), "sanity");
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  1962
    refs()->push(ref);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1963
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1964
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1965
  template <class T> void update_rs(HeapRegion* from, T* p, int tid) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1966
    if (G1DeferredRSUpdate) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1967
      deferred_rs_update(from, p, tid);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1968
    } else {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1969
      immediate_rs_update(from, p, tid);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1970
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1971
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1972
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1973
  HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1974
    HeapWord* obj = NULL;
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  1975
    size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  1976
    if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
17856
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1977
      G1ParGCAllocBufferContainer* alloc_buf = alloc_buffer(purpose);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1978
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  1979
      HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1980
      if (buf == NULL) return NULL; // Let caller handle allocation failure.
17856
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1981
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1982
      add_to_alloc_buffer_waste(alloc_buf->words_remaining_in_retired_buffer());
8871abcf70fa 6976350: G1: deal with fragmentation while copying objects during GC
tamao
parents: 17625
diff changeset
  1983
      alloc_buf->update(false /* end_of_gc */, false /* retain */, buf, gclab_word_size);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1984
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1985
      obj = alloc_buf->allocate(word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1986
      assert(obj != NULL, "buffer was definitely big enough...");
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1987
    } else {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1988
      obj = _g1h->par_allocate_during_gc(purpose, word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1989
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1990
    return obj;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1991
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1992
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1993
  HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1994
    HeapWord* obj = alloc_buffer(purpose)->allocate(word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1995
    if (obj != NULL) return obj;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1996
    return allocate_slow(purpose, word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1997
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1998
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  1999
  void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2000
    if (alloc_buffer(purpose)->contains(obj)) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2001
      assert(alloc_buffer(purpose)->contains(obj + word_sz - 1),
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2002
             "should contain whole object");
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2003
      alloc_buffer(purpose)->undo_allocation(obj, word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2004
    } else {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2005
      CollectedHeap::fill_with_object(obj, word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2006
      add_to_undo_waste(word_sz);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2007
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2008
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2009
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2010
  void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2011
    _evac_failure_cl = evac_failure_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2012
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2013
  OopsInHeapRegionClosure* evac_failure_closure() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2014
    return _evac_failure_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2015
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2016
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2017
  void set_evac_closure(G1ParScanHeapEvacClosure* evac_cl) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2018
    _evac_cl = evac_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2019
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2020
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2021
  void set_partial_scan_closure(G1ParScanPartialArrayClosure* partial_scan_cl) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2022
    _partial_scan_cl = partial_scan_cl;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2023
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2024
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2025
  int* hash_seed() { return &_hash_seed; }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11576
diff changeset
  2026
  uint queue_num() { return _queue_num; }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2027
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2028
  size_t term_attempts() const  { return _term_attempts; }
5891
59044ec3fca3 6946048: G1: improvements to +PrintGCDetails output
tonyp
parents: 5547
diff changeset
  2029
  void note_term_attempt() { _term_attempts++; }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2030
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2031
  void start_strong_roots() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2032
    _start_strong_roots = os::elapsedTime();
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2033
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2034
  void end_strong_roots() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2035
    _strong_roots_time += (os::elapsedTime() - _start_strong_roots);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2036
  }
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2037
  double strong_roots_time() const { return _strong_roots_time; }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2038
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2039
  void start_term_time() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2040
    note_term_attempt();
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2041
    _start_term = os::elapsedTime();
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2042
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2043
  void end_term_time() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2044
    _term_time += (os::elapsedTime() - _start_term);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2045
  }
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2046
  double term_time() const { return _term_time; }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2047
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2048
  double elapsed_time() const {
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2049
    return os::elapsedTime() - _start;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2050
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2051
6251
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2052
  static void
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2053
    print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2054
  void
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2055
    print_termination_stats(int i, outputStream* const st = gclog_or_tty) const;
90e562b9f1cc 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 6247
diff changeset
  2056
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2057
  size_t* surviving_young_words() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2058
    // We add on to hide entry 0 which accumulates surviving words for
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2059
    // age -1 regions (i.e. non-young ones)
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2060
    return _surviving_young_words;
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2061
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2062
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2063
  void retire_alloc_buffers() {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2064
    for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
5347
1de2255c6c2e 6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents: 5078
diff changeset
  2065
      size_t waste = _alloc_buffers[ap]->words_remaining();
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2066
      add_to_alloc_buffer_waste(waste);
13466
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
  2067
      _alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
  2068
                                                 true /* end_of_gc */,
9fdf353d5f4c 6818524: G1: use ergonomic resizing of PLABs
johnc
parents: 13336
diff changeset
  2069
                                                 false /* retain */);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2070
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2071
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2072
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2073
  template <class T> void deal_with_reference(T* ref_to_scan) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2074
    if (has_partial_array_mask(ref_to_scan)) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2075
      _partial_scan_cl->do_oop_nv(ref_to_scan);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2076
    } else {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2077
      // Note: we can use "raw" versions of "region_containing" because
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2078
      // "obj_to_scan" is definitely in the heap, and is not in a
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2079
      // humongous region.
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2080
      HeapRegion* r = _g1h->heap_region_containing_raw(ref_to_scan);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2081
      _evac_cl->set_region(r);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2082
      _evac_cl->do_oop_nv(ref_to_scan);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2083
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2084
  }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2085
6959
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2086
  void deal_with_reference(StarTask ref) {
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2087
    assert(verify_task(ref), "sanity");
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2088
    if (ref.is_narrow()) {
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2089
      deal_with_reference((narrowOop*)ref);
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2090
    } else {
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2091
      deal_with_reference((oop*)ref);
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2092
    }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2093
  }
6959
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2094
01bebea2fd5c 6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents: 6762
diff changeset
  2095
  void trim_queue();
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3191
diff changeset
  2096
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
  2097
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6980
diff changeset
  2098
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP