graal-jvmci-8: src/share/vm/memory/genCollectedHeap.hpp annotate

annotate src/share/vm/memory/genCollectedHeap.hpp @ 23491:88ae10297731

8068162: jvmtiRedefineClasses.cpp: guarantee(false) failed: OLD and/or OBSOLETE method(s) found Summary: adjust Unsafe methods in the itable/vtable if Unsafe is redefined Reviewed-by: coleenp, dcubed Contributed-by: serguei.spitsyn@oracle.com

author	sspitsyn
date	Mon, 26 Jan 2015 15:51:28 -0800
parents	38d6febe66af
children	dd9cc155639c

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1166 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1166 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: 1166 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	25 #ifndef SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	26 #define SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	28 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	29 #include "memory/collectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	30 #include "memory/generation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	31 #include "memory/sharedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	32
0 a61af66fc99e Initial load duke parents: diff changeset	33 class SubTasksDone;
a61af66fc99e Initial load duke parents: diff changeset	34
a61af66fc99e Initial load duke parents: diff changeset	35 // A "GenCollectedHeap" is a SharedHeap that uses generational
a61af66fc99e Initial load duke parents: diff changeset	36 // collection. It is represented with a sequence of Generation's.
a61af66fc99e Initial load duke parents: diff changeset	37 class GenCollectedHeap : public SharedHeap {
a61af66fc99e Initial load duke parents: diff changeset	38 friend class GenCollectorPolicy;
a61af66fc99e Initial load duke parents: diff changeset	39 friend class Generation;
a61af66fc99e Initial load duke parents: diff changeset	40 friend class DefNewGeneration;
a61af66fc99e Initial load duke parents: diff changeset	41 friend class TenuredGeneration;
a61af66fc99e Initial load duke parents: diff changeset	42 friend class ConcurrentMarkSweepGeneration;
a61af66fc99e Initial load duke parents: diff changeset	43 friend class CMSCollector;
a61af66fc99e Initial load duke parents: diff changeset	44 friend class GenMarkSweep;
a61af66fc99e Initial load duke parents: diff changeset	45 friend class VM_GenCollectForAllocation;
a61af66fc99e Initial load duke parents: diff changeset	46 friend class VM_GenCollectFull;
a61af66fc99e Initial load duke parents: diff changeset	47 friend class VM_GenCollectFullConcurrent;
a61af66fc99e Initial load duke parents: diff changeset	48 friend class VM_GC_HeapInspection;
a61af66fc99e Initial load duke parents: diff changeset	49 friend class VM_HeapDumper;
a61af66fc99e Initial load duke parents: diff changeset	50 friend class HeapInspection;
a61af66fc99e Initial load duke parents: diff changeset	51 friend class GCCauseSetter;
a61af66fc99e Initial load duke parents: diff changeset	52 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	53 public:
a61af66fc99e Initial load duke parents: diff changeset	54 enum SomeConstants {
a61af66fc99e Initial load duke parents: diff changeset	55 max_gens = 10
a61af66fc99e Initial load duke parents: diff changeset	56 };
a61af66fc99e Initial load duke parents: diff changeset	57
a61af66fc99e Initial load duke parents: diff changeset	58 friend class VM_PopulateDumpSharedSpace;
a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 protected:
a61af66fc99e Initial load duke parents: diff changeset	61 // Fields:
a61af66fc99e Initial load duke parents: diff changeset	62 static GenCollectedHeap* _gch;
a61af66fc99e Initial load duke parents: diff changeset	63
a61af66fc99e Initial load duke parents: diff changeset	64 private:
a61af66fc99e Initial load duke parents: diff changeset	65 int _n_gens;
a61af66fc99e Initial load duke parents: diff changeset	66 Generation* _gens[max_gens];
a61af66fc99e Initial load duke parents: diff changeset	67 GenerationSpec** _gen_specs;
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // The generational collector policy.
a61af66fc99e Initial load duke parents: diff changeset	70 GenCollectorPolicy* _gen_policy;
a61af66fc99e Initial load duke parents: diff changeset	71
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	72 // Indicates that the most recent previous incremental collection failed.
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	73 // The flag is cleared when an action is taken that might clear the
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	74 // condition that caused that incremental collection to fail.
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	75 bool _incremental_collection_failed;
0 a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77 // In support of ExplicitGCInvokesConcurrent functionality
a61af66fc99e Initial load duke parents: diff changeset	78 unsigned int _full_collections_completed;
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 // Data structure for claiming the (potentially) parallel tasks in
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	81 // (gen-specific) roots processing.
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	82 SubTasksDone* _process_strong_tasks;
0 a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 // In block contents verification, the number of header words to skip
a61af66fc99e Initial load duke parents: diff changeset	85 NOT_PRODUCT(static size_t _skip_header_HeapWords;)
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 protected:
a61af66fc99e Initial load duke parents: diff changeset	88 // Helper functions for allocation
a61af66fc99e Initial load duke parents: diff changeset	89 HeapWord* attempt_allocation(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	90 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	91 bool first_only);
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 // Helper function for two callbacks below.
a61af66fc99e Initial load duke parents: diff changeset	94 // Considers collection of the first max_level+1 generations.
a61af66fc99e Initial load duke parents: diff changeset	95 void do_collection(bool full,
a61af66fc99e Initial load duke parents: diff changeset	96 bool clear_all_soft_refs,
a61af66fc99e Initial load duke parents: diff changeset	97 size_t size,
a61af66fc99e Initial load duke parents: diff changeset	98 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	99 int max_level);
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 // Callback from VM_GenCollectForAllocation operation.
a61af66fc99e Initial load duke parents: diff changeset	102 // This function does everything necessary/possible to satisfy an
a61af66fc99e Initial load duke parents: diff changeset	103 // allocation request that failed in the youngest generation that should
a61af66fc99e Initial load duke parents: diff changeset	104 // have handled it (including collection, expansion, etc.)
a61af66fc99e Initial load duke parents: diff changeset	105 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 // Callback from VM_GenCollectFull operation.
a61af66fc99e Initial load duke parents: diff changeset	108 // Perform a full collection of the first max_level+1 generations.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	109 virtual void do_full_collection(bool clear_all_soft_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	110 void do_full_collection(bool clear_all_soft_refs, int max_level);
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 // Does the "cause" of GC indicate that
a61af66fc99e Initial load duke parents: diff changeset	113 // we absolutely __must__ clear soft refs?
a61af66fc99e Initial load duke parents: diff changeset	114 bool must_clear_all_soft_refs();
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 public:
a61af66fc99e Initial load duke parents: diff changeset	117 GenCollectedHeap(GenCollectorPolicy *policy);
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 GCStats* gc_stats(int level) const;
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // Returns JNI_OK on success
a61af66fc99e Initial load duke parents: diff changeset	122 virtual jint initialize();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	123 char* allocate(size_t alignment,
0 a61af66fc99e Initial load duke parents: diff changeset	124 size_t* _total_reserved, int* _n_covered_regions,
a61af66fc99e Initial load duke parents: diff changeset	125 ReservedSpace* heap_rs);
a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127 // Does operations required after initialization has been done.
a61af66fc99e Initial load duke parents: diff changeset	128 void post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130 // Initialize ("weak") refs processing support
a61af66fc99e Initial load duke parents: diff changeset	131 virtual void ref_processing_init();
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 virtual CollectedHeap::Name kind() const {
a61af66fc99e Initial load duke parents: diff changeset	134 return CollectedHeap::GenCollectedHeap;
a61af66fc99e Initial load duke parents: diff changeset	135 }
a61af66fc99e Initial load duke parents: diff changeset	136
a61af66fc99e Initial load duke parents: diff changeset	137 // The generational collector policy.
a61af66fc99e Initial load duke parents: diff changeset	138 GenCollectorPolicy* gen_policy() const { return _gen_policy; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	139 virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) gen_policy(); }
0 a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141 // Adaptive size policy
a61af66fc99e Initial load duke parents: diff changeset	142 virtual AdaptiveSizePolicy* size_policy() {
a61af66fc99e Initial load duke parents: diff changeset	143 return gen_policy()->size_policy();
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	146 // Return the (conservative) maximum heap alignment
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	147 static size_t conservative_max_heap_alignment() {
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	148 return Generation::GenGrain;
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	149 }
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12030 diff changeset	150
0 a61af66fc99e Initial load duke parents: diff changeset	151 size_t capacity() const;
a61af66fc99e Initial load duke parents: diff changeset	152 size_t used() const;
a61af66fc99e Initial load duke parents: diff changeset	153
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	154 // Save the "used_region" for generations level and lower.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	155 void save_used_regions(int level);
0 a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 size_t max_capacity() const;
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 HeapWord* mem_allocate(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	160 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // We may support a shared contiguous allocation area, if the youngest
a61af66fc99e Initial load duke parents: diff changeset	163 // generation does.
a61af66fc99e Initial load duke parents: diff changeset	164 bool supports_inline_contig_alloc() const;
a61af66fc99e Initial load duke parents: diff changeset	165 HeapWord** top_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	166 HeapWord** end_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // Does this heap support heap inspection? (+PrintClassHistogram)
a61af66fc99e Initial load duke parents: diff changeset	169 virtual bool supports_heap_inspection() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 // Perform a full collection of the heap; intended for use in implementing
a61af66fc99e Initial load duke parents: diff changeset	172 // "System.gc". This implies as full a collection as the CollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	173 // supports. Caller does not hold the Heap_lock on entry.
a61af66fc99e Initial load duke parents: diff changeset	174 void collect(GCCause::Cause cause);
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // The same as above but assume that the caller holds the Heap_lock.
a61af66fc99e Initial load duke parents: diff changeset	177 void collect_locked(GCCause::Cause cause);
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Perform a full collection of the first max_level+1 generations.
a61af66fc99e Initial load duke parents: diff changeset	180 // Mostly used for testing purposes. Caller does not hold the Heap_lock on entry.
a61af66fc99e Initial load duke parents: diff changeset	181 void collect(GCCause::Cause cause, int max_level);
a61af66fc99e Initial load duke parents: diff changeset	182
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	183 // Returns "TRUE" iff "p" points into the committed areas of the heap.
0 a61af66fc99e Initial load duke parents: diff changeset	184 // The methods is_in(), is_in_closed_subset() and is_in_youngest() may
a61af66fc99e Initial load duke parents: diff changeset	185 // be expensive to compute in general, so, to prevent
a61af66fc99e Initial load duke parents: diff changeset	186 // their inadvertent use in product jvm's, we restrict their use to
a61af66fc99e Initial load duke parents: diff changeset	187 // assertion checking or verification only.
a61af66fc99e Initial load duke parents: diff changeset	188 bool is_in(const void* p) const;
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // override
a61af66fc99e Initial load duke parents: diff changeset	191 bool is_in_closed_subset(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	192 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	193 return is_in_reserved(p);
a61af66fc99e Initial load duke parents: diff changeset	194 } else {
a61af66fc99e Initial load duke parents: diff changeset	195 return is_in(p);
a61af66fc99e Initial load duke parents: diff changeset	196 }
a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	199 // Returns true if the reference is to an object in the reserved space
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	200 // for the young generation.
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	201 // Assumes the the young gen address range is less than that of the old gen.
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	202 bool is_in_young(oop p);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	203
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	204 #ifdef ASSERT
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	205 virtual bool is_in_partial_collection(const void* p);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	206 #endif
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	207
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	208 virtual bool is_scavengable(const void* addr) {
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	209 return is_in_young((oop)addr);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	210 }
0 a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 // Iteration functions.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	213 void oop_iterate(ExtendedOopClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	214 void object_iterate(ObjectClosure* cl);
517 e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 356 diff changeset	215 void safe_object_iterate(ObjectClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	216 Space* space_containing(const void* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
a61af66fc99e Initial load duke parents: diff changeset	219 // each address in the (reserved) heap is a member of exactly
a61af66fc99e Initial load duke parents: diff changeset	220 // one block. The defining characteristic of a block is that it is
a61af66fc99e Initial load duke parents: diff changeset	221 // possible to find its size, and thus to progress forward to the next
a61af66fc99e Initial load duke parents: diff changeset	222 // block. (Blocks may be of different sizes.) Thus, blocks may
a61af66fc99e Initial load duke parents: diff changeset	223 // represent Java objects, or they might be free blocks in a
a61af66fc99e Initial load duke parents: diff changeset	224 // free-list-based heap (or subheap), as long as the two kinds are
a61af66fc99e Initial load duke parents: diff changeset	225 // distinguishable and the size of each is determinable.
a61af66fc99e Initial load duke parents: diff changeset	226
a61af66fc99e Initial load duke parents: diff changeset	227 // Returns the address of the start of the "block" that contains the
a61af66fc99e Initial load duke parents: diff changeset	228 // address "addr". We say "blocks" instead of "object" since some heaps
a61af66fc99e Initial load duke parents: diff changeset	229 // may not pack objects densely; a chunk may either be an object or a
a61af66fc99e Initial load duke parents: diff changeset	230 // non-object.
a61af66fc99e Initial load duke parents: diff changeset	231 virtual HeapWord* block_start(const void* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233 // Requires "addr" to be the start of a chunk, and returns its size.
a61af66fc99e Initial load duke parents: diff changeset	234 // "addr + size" is required to be the start of a new chunk, or the end
a61af66fc99e Initial load duke parents: diff changeset	235 // of the active area of the heap. Assumes (and verifies in non-product
a61af66fc99e Initial load duke parents: diff changeset	236 // builds) that addr is in the allocated part of the heap and is
a61af66fc99e Initial load duke parents: diff changeset	237 // the start of a chunk.
a61af66fc99e Initial load duke parents: diff changeset	238 virtual size_t block_size(const HeapWord* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 // Requires "addr" to be the start of a block, and returns "TRUE" iff
a61af66fc99e Initial load duke parents: diff changeset	241 // the block is an object. Assumes (and verifies in non-product
a61af66fc99e Initial load duke parents: diff changeset	242 // builds) that addr is in the allocated part of the heap and is
a61af66fc99e Initial load duke parents: diff changeset	243 // the start of a chunk.
a61af66fc99e Initial load duke parents: diff changeset	244 virtual bool block_is_obj(const HeapWord* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	245
a61af66fc99e Initial load duke parents: diff changeset	246 // Section on TLAB's.
a61af66fc99e Initial load duke parents: diff changeset	247 virtual bool supports_tlab_allocation() const;
a61af66fc99e Initial load duke parents: diff changeset	248 virtual size_t tlab_capacity(Thread* thr) const;
17727 cfd4aac53239 8030177: G1: Enable TLAB resizing brutisso parents: 13059 diff changeset	249 virtual size_t tlab_used(Thread* thr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	250 virtual size_t unsafe_max_tlab_alloc(Thread* thr) const;
a61af66fc99e Initial load duke parents: diff changeset	251 virtual HeapWord* allocate_new_tlab(size_t size);
a61af66fc99e Initial load duke parents: diff changeset	252
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	253 // Can a compiler initialize a new object without store barriers?
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	254 // This permission only extends from the creation of a new object
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	255 // via a TLAB up to the first subsequent safepoint.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	256 virtual bool can_elide_tlab_store_barriers() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	257 return true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	258 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	259
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1028 diff changeset	260 virtual bool card_mark_must_follow_store() const {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1028 diff changeset	261 return UseConcMarkSweepGC;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1028 diff changeset	262 }
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1028 diff changeset	263
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	264 // We don't need barriers for stores to objects in the
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	265 // young gen and, a fortiori, for initializing stores to
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	266 // objects therein. This applies to {DefNew,ParNew}+{Tenured,CMS}
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	267 // only and may need to be re-examined in case other
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	268 // kinds of collectors are implemented in the future.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	269 virtual bool can_elide_initializing_store_barrier(oop new_obj) {
1028 052a899eec3e 6892749: assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC, "...") fails ysr parents: 1027 diff changeset	270 // We wanted to assert that:-
052a899eec3e 6892749: assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC, "...") fails ysr parents: 1027 diff changeset	271 // assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC,
052a899eec3e 6892749: assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC, "...") fails ysr parents: 1027 diff changeset	272 // "Check can_elide_initializing_store_barrier() for this collector");
052a899eec3e 6892749: assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC, "...") fails ysr parents: 1027 diff changeset	273 // but unfortunately the flag UseSerialGC need not necessarily always
052a899eec3e 6892749: assert(UseParNewGC \|\| UseSerialGC \|\| UseConcMarkSweepGC, "...") fails ysr parents: 1027 diff changeset	274 // be set when DefNew+Tenured are being used.
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 3293 diff changeset	275 return is_in_young(new_obj);
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	276 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	277
0 a61af66fc99e Initial load duke parents: diff changeset	278 // The "requestor" generation is performing some garbage collection
a61af66fc99e Initial load duke parents: diff changeset	279 // action for which it would be useful to have scratch space. The
a61af66fc99e Initial load duke parents: diff changeset	280 // requestor promises to allocate no more than "max_alloc_words" in any
a61af66fc99e Initial load duke parents: diff changeset	281 // older generation (via promotion say.) Any blocks of space that can
a61af66fc99e Initial load duke parents: diff changeset	282 // be provided are returned as a list of ScratchBlocks, sorted by
a61af66fc99e Initial load duke parents: diff changeset	283 // decreasing size.
a61af66fc99e Initial load duke parents: diff changeset	284 ScratchBlock* gather_scratch(Generation* requestor, size_t max_alloc_words);
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	285 // Allow each generation to reset any scratch space that it has
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	286 // contributed as it needs.
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	287 void release_scratch();
0 a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 // Ensure parsability: override
a61af66fc99e Initial load duke parents: diff changeset	290 virtual void ensure_parsability(bool retire_tlabs);
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 // Time in ms since the longest time a collector ran in
a61af66fc99e Initial load duke parents: diff changeset	293 // in any generation.
a61af66fc99e Initial load duke parents: diff changeset	294 virtual jlong millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 // Total number of full collections completed.
a61af66fc99e Initial load duke parents: diff changeset	297 unsigned int total_full_collections_completed() {
a61af66fc99e Initial load duke parents: diff changeset	298 assert(_full_collections_completed <= _total_full_collections,
a61af66fc99e Initial load duke parents: diff changeset	299 "Can't complete more collections than were started");
a61af66fc99e Initial load duke parents: diff changeset	300 return _full_collections_completed;
a61af66fc99e Initial load duke parents: diff changeset	301 }
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 // Update above counter, as appropriate, at the end of a stop-world GC cycle
a61af66fc99e Initial load duke parents: diff changeset	304 unsigned int update_full_collections_completed();
a61af66fc99e Initial load duke parents: diff changeset	305 // Update above counter, as appropriate, at the end of a concurrent GC cycle
a61af66fc99e Initial load duke parents: diff changeset	306 unsigned int update_full_collections_completed(unsigned int count);
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 // Update "time of last gc" for all constituent generations
a61af66fc99e Initial load duke parents: diff changeset	309 // to "now".
a61af66fc99e Initial load duke parents: diff changeset	310 void update_time_of_last_gc(jlong now) {
a61af66fc99e Initial load duke parents: diff changeset	311 for (int i = 0; i < _n_gens; i++) {
a61af66fc99e Initial load duke parents: diff changeset	312 _gens[i]->update_time_of_last_gc(now);
a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 // Update the gc statistics for each generation.
a61af66fc99e Initial load duke parents: diff changeset	317 // "level" is the level of the lastest collection
a61af66fc99e Initial load duke parents: diff changeset	318 void update_gc_stats(int current_level, bool full) {
a61af66fc99e Initial load duke parents: diff changeset	319 for (int i = 0; i < _n_gens; i++) {
a61af66fc99e Initial load duke parents: diff changeset	320 _gens[i]->update_gc_stats(current_level, full);
a61af66fc99e Initial load duke parents: diff changeset	321 }
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 // Override.
a61af66fc99e Initial load duke parents: diff changeset	325 bool no_gc_in_progress() { return !is_gc_active(); }
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 // Override.
a61af66fc99e Initial load duke parents: diff changeset	328 void prepare_for_verify();
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // Override.
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4728 diff changeset	331 void verify(bool silent, VerifyOption option);
0 a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 // Override.
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3774 diff changeset	334 virtual void print_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	335 virtual void print_gc_threads_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	336 virtual void gc_threads_do(ThreadClosure* tc) const;
a61af66fc99e Initial load duke parents: diff changeset	337 virtual void print_tracing_info() const;
9076 7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 6725 diff changeset	338 virtual void print_on_error(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 // PrintGC, PrintGCDetails support
a61af66fc99e Initial load duke parents: diff changeset	341 void print_heap_change(size_t prev_used) const;
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 // The functions below are helper functions that a subclass of
a61af66fc99e Initial load duke parents: diff changeset	344 // "CollectedHeap" can use in the implementation of its virtual
a61af66fc99e Initial load duke parents: diff changeset	345 // functions.
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 class GenClosure : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	348 public:
a61af66fc99e Initial load duke parents: diff changeset	349 virtual void do_generation(Generation* gen) = 0;
a61af66fc99e Initial load duke parents: diff changeset	350 };
a61af66fc99e Initial load duke parents: diff changeset	351
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	352 // Apply "cl.do_generation" to all generations in the heap
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	353 // If "old_to_young" determines the order.
0 a61af66fc99e Initial load duke parents: diff changeset	354 void generation_iterate(GenClosure* cl, bool old_to_young);
a61af66fc99e Initial load duke parents: diff changeset	355
a61af66fc99e Initial load duke parents: diff changeset	356 void space_iterate(SpaceClosure* cl);
a61af66fc99e Initial load duke parents: diff changeset	357
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	358 // Return "true" if all generations have reached the
0 a61af66fc99e Initial load duke parents: diff changeset	359 // maximal committed limit that they can reach, without a garbage
a61af66fc99e Initial load duke parents: diff changeset	360 // collection.
a61af66fc99e Initial load duke parents: diff changeset	361 virtual bool is_maximal_no_gc() const;
a61af66fc99e Initial load duke parents: diff changeset	362
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	363 // Return the generation before "gen".
0 a61af66fc99e Initial load duke parents: diff changeset	364 Generation* prev_gen(Generation* gen) const {
a61af66fc99e Initial load duke parents: diff changeset	365 int l = gen->level();
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	366 guarantee(l > 0, "Out of bounds");
330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	367 return _gens[l-1];
0 a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	370 // Return the generation after "gen".
0 a61af66fc99e Initial load duke parents: diff changeset	371 Generation* next_gen(Generation* gen) const {
a61af66fc99e Initial load duke parents: diff changeset	372 int l = gen->level() + 1;
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	373 guarantee(l < _n_gens, "Out of bounds");
330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	374 return _gens[l];
0 a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376
a61af66fc99e Initial load duke parents: diff changeset	377 Generation* get_gen(int i) const {
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	378 guarantee(i >= 0 && i < _n_gens, "Out of bounds");
330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	379 return _gens[i];
0 a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381
a61af66fc99e Initial load duke parents: diff changeset	382 int n_gens() const {
a61af66fc99e Initial load duke parents: diff changeset	383 assert(_n_gens == gen_policy()->number_of_generations(), "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	384 return _n_gens;
a61af66fc99e Initial load duke parents: diff changeset	385 }
a61af66fc99e Initial load duke parents: diff changeset	386
a61af66fc99e Initial load duke parents: diff changeset	387 // Convenience function to be used in situations where the heap type can be
a61af66fc99e Initial load duke parents: diff changeset	388 // asserted to be this type.
a61af66fc99e Initial load duke parents: diff changeset	389 static GenCollectedHeap* heap();
a61af66fc99e Initial load duke parents: diff changeset	390
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4708 diff changeset	391 void set_par_threads(uint t);
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	392 void set_n_termination(uint t);
0 a61af66fc99e Initial load duke parents: diff changeset	393
a61af66fc99e Initial load duke parents: diff changeset	394 // Invoke the "do_oop" method of one of the closures "not_older_gens"
a61af66fc99e Initial load duke parents: diff changeset	395 // or "older_gens" on root locations for the generation at
a61af66fc99e Initial load duke parents: diff changeset	396 // "level". (The "older_gens" closure is used for scanning references
a61af66fc99e Initial load duke parents: diff changeset	397 // from older generations; "not_older_gens" is used everywhere else.)
a61af66fc99e Initial load duke parents: diff changeset	398 // If "younger_gens_as_roots" is false, younger generations are
a61af66fc99e Initial load duke parents: diff changeset	399 // not scanned as roots; in this case, the caller must be arranging to
a61af66fc99e Initial load duke parents: diff changeset	400 // scan the younger generations itself. (For example, a generation might
a61af66fc99e Initial load duke parents: diff changeset	401 // explicitly mark reachable objects in younger generations, to avoid
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 // excess storage retention.)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	403 // The "so" argument determines which of the roots
0 a61af66fc99e Initial load duke parents: diff changeset	404 // the closure is applied to:
a61af66fc99e Initial load duke parents: diff changeset	405 // "SO_None" does none;
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	406 enum ScanningOption {
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	407 SO_None = 0x0,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	408 SO_AllCodeCache = 0x8,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	409 SO_ScavengeCodeCache = 0x10
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	410 };
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	411
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	412 private:
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	413 void process_roots(bool activate_scope,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	414 ScanningOption so,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	415 OopClosure* strong_roots,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	416 OopClosure* weak_roots,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	417 CLDClosure* strong_cld_closure,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	418 CLDClosure* weak_cld_closure,
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	419 CodeBlobClosure* code_roots);
38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	420
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	421 void gen_process_roots(int level,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	422 bool younger_gens_as_roots,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	423 bool activate_scope,
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	424 ScanningOption so,
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	425 OopsInGenClosure* not_older_gens,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	426 OopsInGenClosure* weak_roots,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	427 OopsInGenClosure* older_gens,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	428 CLDClosure* cld_closure,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	429 CLDClosure* weak_cld_closure,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	430 CodeBlobClosure* code_closure);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	431
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	432 public:
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	433 static const bool StrongAndWeakRoots = false;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	434 static const bool StrongRootsOnly = true;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	435
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	436 void gen_process_roots(int level,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	437 bool younger_gens_as_roots,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	438 bool activate_scope,
22909 38d6febe66af 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap mgerdin parents: 20356 diff changeset	439 ScanningOption so,
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	440 bool only_strong_roots,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	441 OopsInGenClosure* not_older_gens,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	442 OopsInGenClosure* older_gens,
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20264 diff changeset	443 CLDClosure* cld_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	444
20257 7426d8d76305 8034761: Remove the do_code_roots parameter from process_strong_roots stefank parents: 20254 diff changeset	445 // Apply "root_closure" to all the weak roots of the system.
7426d8d76305 8034761: Remove the do_code_roots parameter from process_strong_roots stefank parents: 20254 diff changeset	446 // These include JNI weak roots, string table,
7426d8d76305 8034761: Remove the do_code_roots parameter from process_strong_roots stefank parents: 20254 diff changeset	447 // and referents of reachable weak refs.
7426d8d76305 8034761: Remove the do_code_roots parameter from process_strong_roots stefank parents: 20254 diff changeset	448 void gen_process_weak_roots(OopClosure* root_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	449
a61af66fc99e Initial load duke parents: diff changeset	450 // Set the saved marks of generations, if that makes sense.
a61af66fc99e Initial load duke parents: diff changeset	451 // In particular, if any generation might iterate over the oops
a61af66fc99e Initial load duke parents: diff changeset	452 // in other generations, it should call this method.
a61af66fc99e Initial load duke parents: diff changeset	453 void save_marks();
a61af66fc99e Initial load duke parents: diff changeset	454
a61af66fc99e Initial load duke parents: diff changeset	455 // Apply "cur->do_oop" or "older->do_oop" to all the oops in objects
a61af66fc99e Initial load duke parents: diff changeset	456 // allocated since the last call to save_marks in generations at or above
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	457 // "level". The "cur" closure is
0 a61af66fc99e Initial load duke parents: diff changeset	458 // applied to references in the generation at "level", and the "older"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	459 // closure to older generations.
0 a61af66fc99e Initial load duke parents: diff changeset	460 #define GCH_SINCE_SAVE_MARKS_ITERATE_DECL(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	461 void oop_since_save_marks_iterate(int level, \
a61af66fc99e Initial load duke parents: diff changeset	462 OopClosureType* cur, \
a61af66fc99e Initial load duke parents: diff changeset	463 OopClosureType* older);
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL)
a61af66fc99e Initial load duke parents: diff changeset	466
a61af66fc99e Initial load duke parents: diff changeset	467 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 // Returns "true" iff no allocations have occurred in any generation at
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	470 // "level" or above since the last
0 a61af66fc99e Initial load duke parents: diff changeset	471 // call to "save_marks".
a61af66fc99e Initial load duke parents: diff changeset	472 bool no_allocs_since_save_marks(int level);
a61af66fc99e Initial load duke parents: diff changeset	473
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	474 // Returns true if an incremental collection is likely to fail.
1994 6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	475 // We optionally consult the young gen, if asked to do so;
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	476 // otherwise we base our answer on whether the previous incremental
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	477 // collection attempt failed with no corrective action as of yet.
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	478 bool incremental_collection_will_fail(bool consult_young) {
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	479 // Assumes a 2-generation system; the first disjunct remembers if an
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	480 // incremental collection failed, even when we thought (second disjunct)
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	481 // that it would not.
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	482 assert(heap()->collector_policy()->is_two_generation_policy(),
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	483 "the following definition may not be suitable for an n(>2)-generation system");
1994 6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	484 return incremental_collection_failed() \|\|
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	485 (consult_young && !get_gen(0)->collection_attempt_is_safe());
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	486 }
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	487
0 a61af66fc99e Initial load duke parents: diff changeset	488 // If a generation bails out of an incremental collection,
a61af66fc99e Initial load duke parents: diff changeset	489 // it sets this flag.
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	490 bool incremental_collection_failed() const {
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	491 return _incremental_collection_failed;
0 a61af66fc99e Initial load duke parents: diff changeset	492 }
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	493 void set_incremental_collection_failed() {
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	494 _incremental_collection_failed = true;
0 a61af66fc99e Initial load duke parents: diff changeset	495 }
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	496 void clear_incremental_collection_failed() {
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1833 diff changeset	497 _incremental_collection_failed = false;
0 a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	500 // Promotion of obj into gen failed. Try to promote obj to higher
0 a61af66fc99e Initial load duke parents: diff changeset	501 // gens in ascending order; return the new location of obj if successful.
12030 330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	502 // Otherwise, try expand-and-allocate for obj in both the young and old
330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	503 // generation; return the new location of obj if successful. Otherwise, return NULL.
330dfb0476f4 8022800: Use specific generations rather than generation iteration brutisso parents: 11096 diff changeset	504 oop handle_failed_promotion(Generation* old_gen,
0 a61af66fc99e Initial load duke parents: diff changeset	505 oop obj,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	506 size_t obj_size);
0 a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 private:
a61af66fc99e Initial load duke parents: diff changeset	509 // Accessor for memory state verification support
a61af66fc99e Initial load duke parents: diff changeset	510 NOT_PRODUCT(
a61af66fc99e Initial load duke parents: diff changeset	511 static size_t skip_header_HeapWords() { return _skip_header_HeapWords; }
a61af66fc99e Initial load duke parents: diff changeset	512 )
a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514 // Override
a61af66fc99e Initial load duke parents: diff changeset	515 void check_for_non_bad_heap_word_value(HeapWord* addr,
a61af66fc99e Initial load duke parents: diff changeset	516 size_t size) PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 // For use by mark-sweep. As implemented, mark-sweep-compact is global
a61af66fc99e Initial load duke parents: diff changeset	519 // in an essential way: compaction is performed across generations, by
a61af66fc99e Initial load duke parents: diff changeset	520 // iterating over spaces.
a61af66fc99e Initial load duke parents: diff changeset	521 void prepare_for_compaction();
a61af66fc99e Initial load duke parents: diff changeset	522
a61af66fc99e Initial load duke parents: diff changeset	523 // Perform a full collection of the first max_level+1 generations.
a61af66fc99e Initial load duke parents: diff changeset	524 // This is the low level interface used by the public versions of
a61af66fc99e Initial load duke parents: diff changeset	525 // collect() and collect_locked(). Caller holds the Heap_lock on entry.
a61af66fc99e Initial load duke parents: diff changeset	526 void collect_locked(GCCause::Cause cause, int max_level);
a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 // Returns success or failure.
a61af66fc99e Initial load duke parents: diff changeset	529 bool create_cms_collector();
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 // In support of ExplicitGCInvokesConcurrent functionality
a61af66fc99e Initial load duke parents: diff changeset	532 bool should_do_concurrent_full_gc(GCCause::Cause cause);
a61af66fc99e Initial load duke parents: diff changeset	533 void collect_mostly_concurrent(GCCause::Cause cause);
a61af66fc99e Initial load duke parents: diff changeset	534
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	535 // Save the tops of the spaces in all generations
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	536 void record_gen_tops_before_GC() PRODUCT_RETURN;
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 142 diff changeset	537
0 a61af66fc99e Initial load duke parents: diff changeset	538 protected:
a61af66fc99e Initial load duke parents: diff changeset	539 virtual void gc_prologue(bool full);
a61af66fc99e Initial load duke parents: diff changeset	540 virtual void gc_epilogue(bool full);
a61af66fc99e Initial load duke parents: diff changeset	541 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	542
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	543 #endif // SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/genCollectedHeap.hpp @ 23491:88ae10297731