truffle: src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp annotate

annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 6756:b2ef234911c9

7190666: G1: assert(_unused == 0) failed: Inconsistency in PLAB stats Summary: Reset the fields in ParGCAllocBuffer, that are used for accumulating values for the ResizePLAB sensors in PLABStats, to zero after flushing the values to the PLABStats fields. Flush PLABStats values only when retiring the final allocation buffers prior to disposing of a G1ParScanThreadState object, rather than when retiring every allocation buffer. Reviewed-by: jwilhelm, jmasa, ysr

author	johnc
date	Thu, 20 Sep 2012 09:52:56 -0700
parents	9646b7ff4d14
children	2e6857353b2c

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

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 6756:b2ef234911c9