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

annotate src/share/vm/memory/collectorPolicy.hpp @ 12233:40136aa2cdb1

8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes

author	tschatzl
date	Wed, 11 Sep 2013 16:25:02 +0200
parents	1135141fb97e
children	9b4d0569f2f4

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 6725 diff changeset	2 * Copyright (c) 2001, 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: 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
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #ifndef SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	28 #include "memory/allocation.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/barrierSet.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	30 #include "memory/generationSpec.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/genRemSet.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	32 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33
0 a61af66fc99e Initial load duke parents: diff changeset	34 // This class (or more correctly, subtypes of this class)
a61af66fc99e Initial load duke parents: diff changeset	35 // are used to define global garbage collector attributes.
a61af66fc99e Initial load duke parents: diff changeset	36 // This includes initialization of generations and any other
a61af66fc99e Initial load duke parents: diff changeset	37 // shared resources they may need.
a61af66fc99e Initial load duke parents: diff changeset	38 //
a61af66fc99e Initial load duke parents: diff changeset	39 // In general, all flag adjustment and validation should be
a61af66fc99e Initial load duke parents: diff changeset	40 // done in initialize_flags(), which is called prior to
a61af66fc99e Initial load duke parents: diff changeset	41 // initialize_size_info().
a61af66fc99e Initial load duke parents: diff changeset	42 //
a61af66fc99e Initial load duke parents: diff changeset	43 // This class is not fully developed yet. As more collector(s)
a61af66fc99e Initial load duke parents: diff changeset	44 // are added, it is expected that we will come across further
a61af66fc99e Initial load duke parents: diff changeset	45 // behavior that requires global attention. The correct place
a61af66fc99e Initial load duke parents: diff changeset	46 // to deal with those issues is this class.
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 // Forward declarations.
a61af66fc99e Initial load duke parents: diff changeset	49 class GenCollectorPolicy;
a61af66fc99e Initial load duke parents: diff changeset	50 class TwoGenerationCollectorPolicy;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	51 class AdaptiveSizePolicy;
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	52 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	53 class ConcurrentMarkSweepPolicy;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	54 class G1CollectorPolicy;
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	55 #endif // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	56
0 a61af66fc99e Initial load duke parents: diff changeset	57 class GCPolicyCounters;
a61af66fc99e Initial load duke parents: diff changeset	58 class MarkSweepPolicy;
a61af66fc99e Initial load duke parents: diff changeset	59
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3774 diff changeset	60 class CollectorPolicy : public CHeapObj<mtGC> {
0 a61af66fc99e Initial load duke parents: diff changeset	61 protected:
a61af66fc99e Initial load duke parents: diff changeset	62 GCPolicyCounters* _gc_policy_counters;
a61af66fc99e Initial load duke parents: diff changeset	63
a61af66fc99e Initial load duke parents: diff changeset	64 // Requires that the concrete subclass sets the alignment constraints
a61af66fc99e Initial load duke parents: diff changeset	65 // before calling.
a61af66fc99e Initial load duke parents: diff changeset	66 virtual void initialize_flags();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	67 virtual void initialize_size_info();
0 a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 size_t _initial_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	70 size_t _max_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	71 size_t _min_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	72
a61af66fc99e Initial load duke parents: diff changeset	73 size_t _min_alignment;
a61af66fc99e Initial load duke parents: diff changeset	74 size_t _max_alignment;
a61af66fc99e Initial load duke parents: diff changeset	75
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	76 // 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	77 AdaptiveSizePolicy* _size_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	78
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	79 // 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	80 // 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	81 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	82 // 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	83 // 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	84 // 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	85 // 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	86 // 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	87 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	88
0 a61af66fc99e Initial load duke parents: diff changeset	89 CollectorPolicy() :
a61af66fc99e Initial load duke parents: diff changeset	90 _min_alignment(1),
a61af66fc99e Initial load duke parents: diff changeset	91 _max_alignment(1),
a61af66fc99e Initial load duke parents: diff changeset	92 _initial_heap_byte_size(0),
a61af66fc99e Initial load duke parents: diff changeset	93 _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	94 _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	95 _size_policy(NULL),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	96 _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	97 _all_soft_refs_clear(false)
0 a61af66fc99e Initial load duke parents: diff changeset	98 {}
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 public:
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 8016 diff changeset	101 // Return maximum heap alignment that may be imposed by the policy
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 8016 diff changeset	102 static size_t compute_max_alignment();
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 8016 diff changeset	103
0 a61af66fc99e Initial load duke parents: diff changeset	104 void set_min_alignment(size_t align) { _min_alignment = align; }
a61af66fc99e Initial load duke parents: diff changeset	105 size_t min_alignment() { return _min_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	106 void set_max_alignment(size_t align) { _max_alignment = align; }
a61af66fc99e Initial load duke parents: diff changeset	107 size_t max_alignment() { return _max_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 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	110 void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	111 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	112 void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	113 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	114 void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 enum Name {
a61af66fc99e Initial load duke parents: diff changeset	117 CollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	118 TwoGenerationCollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	119 ConcurrentMarkSweepPolicyKind,
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	120 ASConcurrentMarkSweepPolicyKind,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	121 G1CollectorPolicyKind
0 a61af66fc99e Initial load duke parents: diff changeset	122 };
a61af66fc99e Initial load duke parents: diff changeset	123
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	124 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	125 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	126 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	127 // 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	128 // _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	129 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	130 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	131 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	132
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	133 // 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	134 // 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	135 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	136
0 a61af66fc99e Initial load duke parents: diff changeset	137 // Identification methods.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	138 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	139 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
a61af66fc99e Initial load duke parents: diff changeset	140 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	141 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	142 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	143 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	144 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	145 // Note that these are not virtual.
a61af66fc99e Initial load duke parents: diff changeset	146 bool is_generation_policy() { return as_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	147 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	148 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	149 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	150 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	151 bool is_g1_policy() { return as_g1_policy() != NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	152 #else // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	153 bool is_concurrent_mark_sweep_policy() { return false; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	154 bool is_g1_policy() { return false; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	155 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	156
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	157
0 a61af66fc99e Initial load duke parents: diff changeset	158 virtual BarrierSet::Name barrier_set_name() = 0;
a61af66fc99e Initial load duke parents: diff changeset	159 virtual GenRemSet::Name rem_set_name() = 0;
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 // Create the remembered set (to cover the given reserved region,
a61af66fc99e Initial load duke parents: diff changeset	162 // allowing breaking up into at most "max_covered_regions").
a61af66fc99e Initial load duke parents: diff changeset	163 virtual GenRemSet* create_rem_set(MemRegion reserved,
a61af66fc99e Initial load duke parents: diff changeset	164 int max_covered_regions);
a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 // This method controls how a collector satisfies a request
a61af66fc99e Initial load duke parents: diff changeset	167 // for a block of memory. "gc_time_limit_was_exceeded" will
a61af66fc99e Initial load duke parents: diff changeset	168 // be set to true if the adaptive size policy determine that
a61af66fc99e Initial load duke parents: diff changeset	169 // an excessive amount of time is being spent doing collections
a61af66fc99e Initial load duke parents: diff changeset	170 // and caused a NULL to be returned. If a NULL is not returned,
a61af66fc99e Initial load duke parents: diff changeset	171 // "gc_time_limit_was_exceeded" has an undefined meaning.
a61af66fc99e Initial load duke parents: diff changeset	172 virtual HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	173 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	174 bool* gc_overhead_limit_was_exceeded) = 0;
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // This method controls how a collector handles one or more
a61af66fc99e Initial load duke parents: diff changeset	177 // of its generations being fully allocated.
a61af66fc99e Initial load duke parents: diff changeset	178 virtual HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab) = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	179 // This method controls how a collector handles a metadata allocation
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	180 // failure.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	181 virtual MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	182 size_t size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	183 Metaspace::MetadataType mdtype);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	184
0 a61af66fc99e Initial load duke parents: diff changeset	185 // Performace Counter support
a61af66fc99e Initial load duke parents: diff changeset	186 GCPolicyCounters* counters() { return _gc_policy_counters; }
a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 // Create the jstat counters for the GC policy. By default, policy's
a61af66fc99e Initial load duke parents: diff changeset	189 // don't have associated counters, and we complain if this is invoked.
a61af66fc99e Initial load duke parents: diff changeset	190 virtual void initialize_gc_policy_counters() {
a61af66fc99e Initial load duke parents: diff changeset	191 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	192 }
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	195 return CollectorPolicy::CollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	196 }
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 // Returns true if a collector has eden space with soft end.
a61af66fc99e Initial load duke parents: diff changeset	199 virtual bool has_soft_ended_eden() {
a61af66fc99e Initial load duke parents: diff changeset	200 return false;
a61af66fc99e Initial load duke parents: diff changeset	201 }
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 };
a61af66fc99e Initial load duke parents: diff changeset	204
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	205 class ClearedAllSoftRefs : public StackObj {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	206 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	207 CollectorPolicy* _collector_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	208 public:
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	209 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	210 CollectorPolicy* collector_policy) :
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	211 _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	212 _collector_policy(collector_policy) {}
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	213
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	214 ~ClearedAllSoftRefs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	215 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	216 _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	217 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	218 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	219 };
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	220
0 a61af66fc99e Initial load duke parents: diff changeset	221 class GenCollectorPolicy : public CollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	222 protected:
a61af66fc99e Initial load duke parents: diff changeset	223 size_t _min_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	224 size_t _initial_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	225 size_t _max_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	226
a61af66fc99e Initial load duke parents: diff changeset	227 GenerationSpec **_generations;
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // Return true if an allocation should be attempted in the older
a61af66fc99e Initial load duke parents: diff changeset	230 // generation if it fails in the younger generation. Return
a61af66fc99e Initial load duke parents: diff changeset	231 // false, otherwise.
a61af66fc99e Initial load duke parents: diff changeset	232 virtual bool should_try_older_generation_allocation(size_t word_size) const;
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	235 void initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Try to allocate space by expanding the heap.
a61af66fc99e Initial load duke parents: diff changeset	238 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	239
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	240 // 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	241 // result = base_size / (NewRatio + 1)
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	242 // and align by min_alignment()
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	243 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	244
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	245 // 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	246 // min_alignment.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	247 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
0 a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 public:
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	250 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	251 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	252 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	253 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	254 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	255 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	256 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	257
0 a61af66fc99e Initial load duke parents: diff changeset	258 virtual int number_of_generations() = 0;
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 virtual GenerationSpec **generations() {
a61af66fc99e Initial load duke parents: diff changeset	261 assert(_generations != NULL, "Sanity check");
a61af66fc99e Initial load duke parents: diff changeset	262 return _generations;
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 virtual GenCollectorPolicy* as_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 virtual void initialize_generations() = 0;
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 virtual void initialize_all() {
a61af66fc99e Initial load duke parents: diff changeset	270 initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	271 initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	272 initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274
a61af66fc99e Initial load duke parents: diff changeset	275 HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	276 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	277 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	280
a61af66fc99e Initial load duke parents: diff changeset	281 // Adaptive size policy
a61af66fc99e Initial load duke parents: diff changeset	282 virtual void initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	283 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	284 size_t init_survivor_size);
a61af66fc99e Initial load duke parents: diff changeset	285 };
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 // All of hotspot's current collectors are subtypes of this
a61af66fc99e Initial load duke parents: diff changeset	288 // class. Currently, these collectors all use the same gen[0],
a61af66fc99e Initial load duke parents: diff changeset	289 // but have different gen[1] types. If we add another subtype
a61af66fc99e Initial load duke parents: diff changeset	290 // of CollectorPolicy, this class should be broken out into
a61af66fc99e Initial load duke parents: diff changeset	291 // its own file.
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	294 protected:
a61af66fc99e Initial load duke parents: diff changeset	295 size_t _min_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	296 size_t _initial_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	297 size_t _max_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	300 void initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	301 void initialize_generations() { ShouldNotReachHere(); }
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 public:
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	304 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	305 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	306 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	307 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	308 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	309 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	310 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	311
0 a61af66fc99e Initial load duke parents: diff changeset	312 // Inherited methods
a61af66fc99e Initial load duke parents: diff changeset	313 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 int number_of_generations() { return 2; }
a61af66fc99e Initial load duke parents: diff changeset	316 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
a61af66fc99e Initial load duke parents: diff changeset	317 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; }
a61af66fc99e Initial load duke parents: diff changeset	318
a61af66fc99e Initial load duke parents: diff changeset	319 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	320 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	321 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	322
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	323 // Returns true is gen0 sizes were adjusted
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	324 bool adjust_gen0_sizes(size_t* gen0_size_ptr, size_t* gen1_size_ptr,
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 6725 diff changeset	325 const size_t heap_size, const size_t min_gen1_size);
0 a61af66fc99e Initial load duke parents: diff changeset	326 };
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	329 protected:
a61af66fc99e Initial load duke parents: diff changeset	330 void initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 public:
a61af66fc99e Initial load duke parents: diff changeset	333 MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 void initialize_gc_policy_counters();
a61af66fc99e Initial load duke parents: diff changeset	338 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	339
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	340 #endif // SHARE_VM_MEMORY_COLLECTORPOLICY_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/memory/collectorPolicy.hpp @ 12233:40136aa2cdb1