truffle: src/share/vm/memory/collectorPolicy.hpp annotate

annotate src/share/vm/memory/collectorPolicy.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	1d01a7f3a336
children	52b4284cb496

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
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	64 virtual void initialize_alignments() = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	65 virtual void initialize_flags();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	66 virtual void initialize_size_info();
0 a61af66fc99e Initial load duke parents: diff changeset	67
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	68 DEBUG_ONLY(virtual void assert_flags();)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	69 DEBUG_ONLY(virtual void assert_size_info();)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	70
0 a61af66fc99e Initial load duke parents: diff changeset	71 size_t _initial_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	72 size_t _max_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	73 size_t _min_heap_byte_size;
a61af66fc99e Initial load duke parents: diff changeset	74
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	75 size_t _space_alignment;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	76 size_t _heap_alignment;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	77
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	78 // Needed to keep information if MaxHeapSize was set on the command line
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	79 // when the flag value is aligned etc by ergonomics
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	80 bool _max_heap_size_cmdline;
0 a61af66fc99e Initial load duke parents: diff changeset	81
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	82 // 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	83 AdaptiveSizePolicy* _size_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	84
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	85 // 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	86 // 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	87 bool _should_clear_all_soft_refs;
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	88
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	89 // 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	90 // 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	91 // 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	92 // 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	93 // 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	94 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	95
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	96 CollectorPolicy();
0 a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98 public:
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	99 virtual void initialize_all() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	100 initialize_alignments();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	101 initialize_flags();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	102 initialize_size_info();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	103 }
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 8016 diff changeset	104
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	105 // Return maximum heap alignment that may be imposed by the policy
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	106 static size_t compute_heap_alignment();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	107
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	108 size_t space_alignment() { return _space_alignment; }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	109 size_t heap_alignment() { return _heap_alignment; }
0 a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
a61af66fc99e Initial load duke parents: diff changeset	112 size_t max_heap_byte_size() { return _max_heap_byte_size; }
a61af66fc99e Initial load duke parents: diff changeset	113 size_t min_heap_byte_size() { return _min_heap_byte_size; }
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 enum Name {
a61af66fc99e Initial load duke parents: diff changeset	116 CollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	117 TwoGenerationCollectorPolicyKind,
a61af66fc99e Initial load duke parents: diff changeset	118 ConcurrentMarkSweepPolicyKind,
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	119 ASConcurrentMarkSweepPolicyKind,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	120 G1CollectorPolicyKind
0 a61af66fc99e Initial load duke parents: diff changeset	121 };
a61af66fc99e Initial load duke parents: diff changeset	122
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	123 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	124 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	125 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	126 // 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	127 // _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	128 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	129 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	130 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	131
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	132 // 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	133 // 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	134 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	135
0 a61af66fc99e Initial load duke parents: diff changeset	136 // Identification methods.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	137 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	138 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
a61af66fc99e Initial load duke parents: diff changeset	139 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	140 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	141 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	142 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	143 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	144 // Note that these are not virtual.
a61af66fc99e Initial load duke parents: diff changeset	145 bool is_generation_policy() { return as_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	146 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	147 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	148 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	149 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	150 bool is_g1_policy() { return as_g1_policy() != NULL; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	151 #else // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	152 bool is_concurrent_mark_sweep_policy() { return false; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	153 bool is_g1_policy() { return false; }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	154 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	155
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	156
0 a61af66fc99e Initial load duke parents: diff changeset	157 virtual BarrierSet::Name barrier_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;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	177 // 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	178 // failure.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	179 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	180 size_t size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	181 Metaspace::MetadataType mdtype);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	182
0 a61af66fc99e Initial load duke parents: diff changeset	183 // Performace Counter support
a61af66fc99e Initial load duke parents: diff changeset	184 GCPolicyCounters* counters() { return _gc_policy_counters; }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 // Create the jstat counters for the GC policy. By default, policy's
a61af66fc99e Initial load duke parents: diff changeset	187 // don't have associated counters, and we complain if this is invoked.
a61af66fc99e Initial load duke parents: diff changeset	188 virtual void initialize_gc_policy_counters() {
a61af66fc99e Initial load duke parents: diff changeset	189 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	190 }
a61af66fc99e Initial load duke parents: diff changeset	191
a61af66fc99e Initial load duke parents: diff changeset	192 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	193 return CollectorPolicy::CollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	194 }
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Returns true if a collector has eden space with soft end.
a61af66fc99e Initial load duke parents: diff changeset	197 virtual bool has_soft_ended_eden() {
a61af66fc99e Initial load duke parents: diff changeset	198 return false;
a61af66fc99e Initial load duke parents: diff changeset	199 }
a61af66fc99e Initial load duke parents: diff changeset	200
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	201 // Do any updates required to global flags that are due to heap initialization
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	202 // changes
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	203 virtual void post_heap_initialize() = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	204 };
a61af66fc99e Initial load duke parents: diff changeset	205
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	206 class ClearedAllSoftRefs : public StackObj {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	207 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	208 CollectorPolicy* _collector_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	209 public:
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	210 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	211 CollectorPolicy* collector_policy) :
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	212 _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	213 _collector_policy(collector_policy) {}
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	214
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	215 ~ClearedAllSoftRefs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	216 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	217 _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	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 };
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 356 diff changeset	221
0 a61af66fc99e Initial load duke parents: diff changeset	222 class GenCollectorPolicy : public CollectorPolicy {
17898 1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	223 friend class TestGenCollectorPolicy;
0 a61af66fc99e Initial load duke parents: diff changeset	224 protected:
a61af66fc99e Initial load duke parents: diff changeset	225 size_t _min_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	226 size_t _initial_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	227 size_t _max_gen0_size;
a61af66fc99e Initial load duke parents: diff changeset	228
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	229 // _gen_alignment and _space_alignment will have the same value most of the
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	230 // time. When using large pages they can differ.
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	231 size_t _gen_alignment;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	232
0 a61af66fc99e Initial load duke parents: diff changeset	233 GenerationSpec **_generations;
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235 // Return true if an allocation should be attempted in the older
a61af66fc99e Initial load duke parents: diff changeset	236 // generation if it fails in the younger generation. Return
a61af66fc99e Initial load duke parents: diff changeset	237 // false, otherwise.
a61af66fc99e Initial load duke parents: diff changeset	238 virtual bool should_try_older_generation_allocation(size_t word_size) const;
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	241 void initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	242
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	243 DEBUG_ONLY(void assert_flags();)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	244 DEBUG_ONLY(void assert_size_info();)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	245
0 a61af66fc99e Initial load duke parents: diff changeset	246 // Try to allocate space by expanding the heap.
a61af66fc99e Initial load duke parents: diff changeset	247 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	248
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	249 // Compute max heap alignment
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	250 size_t compute_max_alignment();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	251
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	252 // Scale the base_size by NewRatio according to
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	253 // result = base_size / (NewRatio + 1)
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	254 // and align by min_alignment()
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	255 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	256
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	257 // Bound the value by the given maximum minus the min_alignment
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	258 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
0 a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 public:
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	261 GenCollectorPolicy();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	262
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	263 // Accessors
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12233 diff changeset	264 size_t min_gen0_size() { return _min_gen0_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	265 size_t initial_gen0_size() { return _initial_gen0_size; }
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12233 diff changeset	266 size_t max_gen0_size() { return _max_gen0_size; }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	267 size_t gen_alignment() { return _gen_alignment; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	268
0 a61af66fc99e Initial load duke parents: diff changeset	269 virtual int number_of_generations() = 0;
a61af66fc99e Initial load duke parents: diff changeset	270
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	271 virtual GenerationSpec **generations() {
0 a61af66fc99e Initial load duke parents: diff changeset	272 assert(_generations != NULL, "Sanity check");
a61af66fc99e Initial load duke parents: diff changeset	273 return _generations;
a61af66fc99e Initial load duke parents: diff changeset	274 }
a61af66fc99e Initial load duke parents: diff changeset	275
a61af66fc99e Initial load duke parents: diff changeset	276 virtual GenCollectorPolicy* as_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	277
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	278 virtual void initialize_generations() { };
0 a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 virtual void initialize_all() {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	281 CollectorPolicy::initialize_all();
0 a61af66fc99e Initial load duke parents: diff changeset	282 initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	285 size_t young_gen_size_lower_bound();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	286
0 a61af66fc99e Initial load duke parents: diff changeset	287 HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	288 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	289 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 // Adaptive size policy
a61af66fc99e Initial load duke parents: diff changeset	294 virtual void initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	295 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	296 size_t init_survivor_size);
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	297
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	298 virtual void post_heap_initialize() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	299 assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	300 }
0 a61af66fc99e Initial load duke parents: diff changeset	301 };
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 // All of hotspot's current collectors are subtypes of this
a61af66fc99e Initial load duke parents: diff changeset	304 // class. Currently, these collectors all use the same gen[0],
a61af66fc99e Initial load duke parents: diff changeset	305 // but have different gen[1] types. If we add another subtype
a61af66fc99e Initial load duke parents: diff changeset	306 // of CollectorPolicy, this class should be broken out into
a61af66fc99e Initial load duke parents: diff changeset	307 // its own file.
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	310 protected:
a61af66fc99e Initial load duke parents: diff changeset	311 size_t _min_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	312 size_t _initial_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	313 size_t _max_gen1_size;
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 void initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	316 void initialize_size_info();
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	317
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	318 DEBUG_ONLY(void assert_flags();)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	319 DEBUG_ONLY(void assert_size_info();)
0 a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 public:
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	322 TwoGenerationCollectorPolicy() : GenCollectorPolicy(), _min_gen1_size(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	323 _initial_gen1_size(0), _max_gen1_size(0) {}
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	324
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	325 // Accessors
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12233 diff changeset	326 size_t min_gen1_size() { return _min_gen1_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	327 size_t initial_gen1_size() { return _initial_gen1_size; }
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12233 diff changeset	328 size_t max_gen1_size() { return _max_gen1_size; }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	329
0 a61af66fc99e Initial load duke parents: diff changeset	330 // Inherited methods
a61af66fc99e Initial load duke parents: diff changeset	331 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	332
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	333 int number_of_generations() { return 2; }
46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13057 diff changeset	334 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
0 a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load duke parents: diff changeset	337 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
a61af66fc99e Initial load duke parents: diff changeset	338 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	339
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13060 diff changeset	340 // Returns true if gen0 sizes were adjusted
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	341 bool adjust_gen0_sizes(size_t* gen0_size_ptr, size_t* gen1_size_ptr,
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13060 diff changeset	342 const size_t heap_size);
0 a61af66fc99e Initial load duke parents: diff changeset	343 };
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
a61af66fc99e Initial load duke parents: diff changeset	346 protected:
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	347 void initialize_alignments();
0 a61af66fc99e Initial load duke parents: diff changeset	348 void initialize_generations();
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350 public:
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	351 MarkSweepPolicy() {}
0 a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 void initialize_gc_policy_counters();
a61af66fc99e Initial load duke parents: diff changeset	356 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	357
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	358 #endif // SHARE_VM_MEMORY_COLLECTORPOLICY_HPP

Mercurial > hg > truffle

annotate src/share/vm/memory/collectorPolicy.hpp @ 20543:e7d0505c8a30