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

annotate src/share/vm/memory/collectorPolicy.hpp @ 1721:413ad0331a0c

6977924: Changes for 6975078 produce build error with certain gcc versions Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error. Reviewed-by: jcoomes, ysr, phh

author	johnc
date	Wed, 18 Aug 2010 10:59:06 -0700
parents	c18cbe5936b8
children	f95d63e2154a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	2 * Copyright (c) 2001, 2010, 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: 1387 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 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: 1387 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
a61af66fc99e Initial load duke parents: diff changeset	25 // This class (or more correctly, subtypes of this class)
a61af66fc99e Initial load duke parents: diff changeset	26 // are used to define global garbage collector attributes.
a61af66fc99e Initial load duke parents: diff changeset	27 // This includes initialization of generations and any other
a61af66fc99e Initial load duke parents: diff changeset	28 // shared resources they may need.
a61af66fc99e Initial load duke parents: diff changeset	29 //
a61af66fc99e Initial load duke parents: diff changeset	30 // In general, all flag adjustment and validation should be
a61af66fc99e Initial load duke parents: diff changeset	31 // done in initialize_flags(), which is called prior to
a61af66fc99e Initial load duke parents: diff changeset	32 // initialize_size_info().
a61af66fc99e Initial load duke parents: diff changeset	33 //
a61af66fc99e Initial load duke parents: diff changeset	34 // This class is not fully developed yet. As more collector(s)
a61af66fc99e Initial load duke parents: diff changeset	35 // are added, it is expected that we will come across further
a61af66fc99e Initial load duke parents: diff changeset	36 // behavior that requires global attention. The correct place
a61af66fc99e Initial load duke parents: diff changeset	37 // to deal with those issues is this class.
a61af66fc99e Initial load duke parents: diff changeset	38
a61af66fc99e Initial load duke parents: diff changeset	39 // Forward declarations.
a61af66fc99e Initial load duke parents: diff changeset	40 class GenCollectorPolicy;
a61af66fc99e Initial load duke parents: diff changeset	41 class TwoGenerationCollectorPolicy;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	42 class AdaptiveSizePolicy;
0 a61af66fc99e Initial load duke parents: diff changeset	43 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	44 class ConcurrentMarkSweepPolicy;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	45 class G1CollectorPolicy;
0 a61af66fc99e Initial load duke parents: diff changeset	46 #endif // SERIALGC
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	47
0 a61af66fc99e Initial load duke parents: diff changeset	48 class GCPolicyCounters;
a61af66fc99e Initial load duke parents: diff changeset	49 class PermanentGenerationSpec;
a61af66fc99e Initial load duke parents: diff changeset	50 class MarkSweepPolicy;
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 class CollectorPolicy : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	53 protected:
a61af66fc99e Initial load duke parents: diff changeset	54 PermanentGenerationSpec *_permanent_generation;
a61af66fc99e Initial load duke parents: diff changeset	55 GCPolicyCounters* _gc_policy_counters;
a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57 // Requires that the concrete subclass sets the alignment constraints
a61af66fc99e Initial load duke parents: diff changeset	58 // before calling.
a61af66fc99e Initial load duke parents: diff changeset	59 virtual void initialize_flags();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	60 virtual void initialize_size_info();
0 a61af66fc99e Initial load duke parents: diff changeset	61 // Initialize "_permanent_generation" to a spec for the given kind of
a61af66fc99e Initial load duke parents: diff changeset	62 // Perm Gen.
a61af66fc99e Initial load duke parents: diff changeset	63 void initialize_perm_generation(PermGen::Name pgnm);
a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 size_t _initial_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	66 size_t _max_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	67 size_t _min_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 size_t _min_alignment;
a61af66fc99e Initial load duke parents: diff changeset	70 size_t _max_alignment;
a61af66fc99e Initial load duke parents: diff changeset	71
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	72 // The sizing of the heap are controlled by a sizing policy.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	73 AdaptiveSizePolicy* _size_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	74
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	75 // Set to true when policy wants soft refs cleared.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	76 // Reset to false by gc after it clears all soft refs.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	77 bool _should_clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	78 // Set to true by the GC if the just-completed gc cleared all
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	79 // softrefs. This is set to true whenever a gc clears all softrefs, and
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	80 // set to false each time gc returns to the mutator. For example, in the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	81 // ParallelScavengeHeap case the latter would be done toward the end of
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	82 // mem_allocate() where it returns op.result()
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	83 bool _all_soft_refs_clear;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	84
0 a61af66fc99e Initial load duke parents: diff changeset	85 CollectorPolicy() :
a61af66fc99e Initial load duke parents: diff changeset	86 _min_alignment(1),
a61af66fc99e Initial load duke parents: diff changeset	87 _max_alignment(1),
a61af66fc99e Initial load duke parents: diff changeset	88 _initial_heap_byte_size(0),
a61af66fc99e Initial load duke parents: diff changeset	89 _max_heap_byte_size(0),
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	90 _min_heap_byte_size(0),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	91 _size_policy(NULL),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	92 _should_clear_all_soft_refs(false),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	93 _all_soft_refs_clear(false)
0 a61af66fc99e Initial load duke parents: diff changeset	94 {}
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 public:
a61af66fc99e Initial load duke parents: diff changeset	97 void set_min_alignment(size_t align) { _min_alignment = align; }
a61af66fc99e Initial load duke parents: diff changeset	98 size_t min_alignment() { return _min_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	99 void set_max_alignment(size_t align) { _max_alignment = align; }
a61af66fc99e Initial load duke parents: diff changeset	100 size_t max_alignment() { return _max_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	101
a61af66fc99e Initial load duke parents: diff changeset	102 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	103 void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	104 size_t max_heap_byte_size() { return _max_heap_byte_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	105 void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	106 size_t min_heap_byte_size() { return _min_heap_byte_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	107 void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 enum Name {
a61af66fc99e Initial load duke parents: diff changeset	110 CollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	111 TwoGenerationCollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	112 ConcurrentMarkSweepPolicyKind,
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	113 ASConcurrentMarkSweepPolicyKind,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	114 G1CollectorPolicyKind
0 a61af66fc99e Initial load duke parents: diff changeset	115 };
a61af66fc99e Initial load duke parents: diff changeset	116
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	117 AdaptiveSizePolicy* size_policy() { return _size_policy; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	118 bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	119 void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	120 // Returns the current value of _should_clear_all_soft_refs.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	121 // _should_clear_all_soft_refs is set to false as a side effect.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	122 bool use_should_clear_all_soft_refs(bool v);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	123 bool all_soft_refs_clear() { return _all_soft_refs_clear; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	124 void set_all_soft_refs_clear(bool v) { _all_soft_refs_clear = v; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	125
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	126 // Called by the GC after Soft Refs have been cleared to indicate
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	127 // that the request in _should_clear_all_soft_refs has been fulfilled.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	128 void cleared_all_soft_refs();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	129
0 a61af66fc99e Initial load duke parents: diff changeset	130 // Identification methods.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	131 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	132 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
a61af66fc99e Initial load duke parents: diff changeset	133 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
a61af66fc99e Initial load duke parents: diff changeset	134 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	135 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	136 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	137 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	138 // Note that these are not virtual.
a61af66fc99e Initial load duke parents: diff changeset	139 bool is_generation_policy() { return as_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	140 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	141 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	142 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	143 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	144 bool is_g1_policy() { return as_g1_policy() != NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	145 #else // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	146 bool is_concurrent_mark_sweep_policy() { return false; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	147 bool is_g1_policy() { return false; }
0 a61af66fc99e Initial load duke parents: diff changeset	148 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	149
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	150
0 a61af66fc99e Initial load duke parents: diff changeset	151 virtual PermanentGenerationSpec *permanent_generation() {
a61af66fc99e Initial load duke parents: diff changeset	152 assert(_permanent_generation != NULL, "Sanity check");
a61af66fc99e Initial load duke parents: diff changeset	153 return _permanent_generation;
a61af66fc99e Initial load duke parents: diff changeset	154 }
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 virtual BarrierSet::Name barrier_set_name() = 0;
a61af66fc99e Initial load duke parents: diff changeset	157 virtual GenRemSet::Name rem_set_name() = 0;
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // Create the remembered set (to cover the given reserved region,
a61af66fc99e Initial load duke parents: diff changeset	160 // allowing breaking up into at most "max_covered_regions").
a61af66fc99e Initial load duke parents: diff changeset	161 virtual GenRemSet* create_rem_set(MemRegion reserved,
a61af66fc99e Initial load duke parents: diff changeset	162 int max_covered_regions);
a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 // This method controls how a collector satisfies a request
a61af66fc99e Initial load duke parents: diff changeset	165 // for a block of memory. "gc_time_limit_was_exceeded" will
a61af66fc99e Initial load duke parents: diff changeset	166 // be set to true if the adaptive size policy determine that
a61af66fc99e Initial load duke parents: diff changeset	167 // an excessive amount of time is being spent doing collections
a61af66fc99e Initial load duke parents: diff changeset	168 // and caused a NULL to be returned. If a NULL is not returned,
a61af66fc99e Initial load duke parents: diff changeset	169 // "gc_time_limit_was_exceeded" has an undefined meaning.
a61af66fc99e Initial load duke parents: diff changeset	170 virtual HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	171 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	172 bool* gc_overhead_limit_was_exceeded) = 0;
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 // This method controls how a collector handles one or more
a61af66fc99e Initial load duke parents: diff changeset	175 // of its generations being fully allocated.
a61af66fc99e Initial load duke parents: diff changeset	176 virtual HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab) = 0;
a61af66fc99e Initial load duke parents: diff changeset	177 // Performace Counter support
a61af66fc99e Initial load duke parents: diff changeset	178 GCPolicyCounters* counters() { return _gc_policy_counters; }
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 // Create the jstat counters for the GC policy. By default, policy's
a61af66fc99e Initial load duke parents: diff changeset	181 // don't have associated counters, and we complain if this is invoked.
a61af66fc99e Initial load duke parents: diff changeset	182 virtual void initialize_gc_policy_counters() {
a61af66fc99e Initial load duke parents: diff changeset	183 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	187 return CollectorPolicy::CollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	188 }
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // Returns true if a collector has eden space with soft end.
a61af66fc99e Initial load duke parents: diff changeset	191 virtual bool has_soft_ended_eden() {
a61af66fc99e Initial load duke parents: diff changeset	192 return false;
a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 };
a61af66fc99e Initial load duke parents: diff changeset	196
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	197 class ClearedAllSoftRefs : public StackObj {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	198 bool _clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	199 CollectorPolicy* _collector_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	200 public:
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	201 ClearedAllSoftRefs(bool clear_all_soft_refs,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	202 CollectorPolicy* collector_policy) :
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	203 _clear_all_soft_refs(clear_all_soft_refs),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	204 _collector_policy(collector_policy) {}
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	205
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	206 ~ClearedAllSoftRefs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	207 if (_clear_all_soft_refs) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	208 _collector_policy->cleared_all_soft_refs();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	209 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	210 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	211 };
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	212
0 a61af66fc99e Initial load duke parents: diff changeset	213 class GenCollectorPolicy : public CollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	214 protected:
a61af66fc99e Initial load duke parents: diff changeset	215 size_t _min_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	216 size_t _initial_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	217 size_t _max_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 GenerationSpec **_generations;
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 // Return true if an allocation should be attempted in the older
a61af66fc99e Initial load duke parents: diff changeset	222 // generation if it fails in the younger generation. Return
a61af66fc99e Initial load duke parents: diff changeset	223 // false, otherwise.
a61af66fc99e Initial load duke parents: diff changeset	224 virtual bool should_try_older_generation_allocation(size_t word_size) const;
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	227 void initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // Try to allocate space by expanding the heap.
a61af66fc99e Initial load duke parents: diff changeset	230 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // compute max heap alignment
a61af66fc99e Initial load duke parents: diff changeset	233 size_t compute_max_alignment();
a61af66fc99e Initial load duke parents: diff changeset	234
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	235 // Scale the base_size by NewRation according to
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	236 // result = base_size / (NewRatio + 1)
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	237 // and align by min_alignment()
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	238 size_t scale_by_NewRatio_aligned(size_t base_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	239
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	240 // Bound the value by the given maximum minus the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	241 // min_alignment.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	242 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
0 a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 public:
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	245 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	246 size_t min_gen0_size() { return _min_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	247 void set_min_gen0_size(size_t v) { _min_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	248 size_t initial_gen0_size() { return _initial_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	249 void set_initial_gen0_size(size_t v) { _initial_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	250 size_t max_gen0_size() { return _max_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	251 void set_max_gen0_size(size_t v) { _max_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	252
0 a61af66fc99e Initial load duke parents: diff changeset	253 virtual int number_of_generations() = 0;
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 virtual GenerationSpec **generations() {
a61af66fc99e Initial load duke parents: diff changeset	256 assert(_generations != NULL, "Sanity check");
a61af66fc99e Initial load duke parents: diff changeset	257 return _generations;
a61af66fc99e Initial load duke parents: diff changeset	258 }
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 virtual GenCollectorPolicy* as_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 virtual void initialize_generations() = 0;
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 virtual void initialize_all() {
a61af66fc99e Initial load duke parents: diff changeset	265 initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	266 initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	267 initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	271 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	272 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	275
a61af66fc99e Initial load duke parents: diff changeset	276 // The size that defines a "large array".
a61af66fc99e Initial load duke parents: diff changeset	277 virtual size_t large_typearray_limit();
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 // Adaptive size policy
a61af66fc99e Initial load duke parents: diff changeset	280 virtual void initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	281 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	282 size_t init_survivor_size);
a61af66fc99e Initial load duke parents: diff changeset	283 };
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 // All of hotspot's current collectors are subtypes of this
a61af66fc99e Initial load duke parents: diff changeset	286 // class. Currently, these collectors all use the same gen[0],
a61af66fc99e Initial load duke parents: diff changeset	287 // but have different gen[1] types. If we add another subtype
a61af66fc99e Initial load duke parents: diff changeset	288 // of CollectorPolicy, this class should be broken out into
a61af66fc99e Initial load duke parents: diff changeset	289 // its own file.
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	292 protected:
a61af66fc99e Initial load duke parents: diff changeset	293 size_t _min_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	294 size_t _initial_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	295 size_t _max_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	298 void initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	299 void initialize_generations() { ShouldNotReachHere(); }
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 public:
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	302 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	303 size_t min_gen1_size() { return _min_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	304 void set_min_gen1_size(size_t v) { _min_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	305 size_t initial_gen1_size() { return _initial_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	306 void set_initial_gen1_size(size_t v) { _initial_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	307 size_t max_gen1_size() { return _max_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	308 void set_max_gen1_size(size_t v) { _max_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	309
0 a61af66fc99e Initial load duke parents: diff changeset	310 // Inherited methods
a61af66fc99e Initial load duke parents: diff changeset	311 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	312
a61af66fc99e Initial load duke parents: diff changeset	313 int number_of_generations() { return 2; }
a61af66fc99e Initial load duke parents: diff changeset	314 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
a61af66fc99e Initial load duke parents: diff changeset	315 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; }
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	318 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	319 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	320
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	321 // Returns true is gen0 sizes were adjusted
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	322 bool adjust_gen0_sizes(size_t* gen0_size_ptr, size_t* gen1_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	323 size_t heap_size, size_t min_gen1_size);
0 a61af66fc99e Initial load duke parents: diff changeset	324 };
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	327 protected:
a61af66fc99e Initial load duke parents: diff changeset	328 void initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 public:
a61af66fc99e Initial load duke parents: diff changeset	331 MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 void initialize_gc_policy_counters();
a61af66fc99e Initial load duke parents: diff changeset	336 };

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/collectorPolicy.hpp @ 1721:413ad0331a0c