graal-compiler: src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.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	f2110083203d
children	46d7652b223c

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 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_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "gc_implementation/shared/gcPolicyCounters.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	33 #include "gc_implementation/shared/gcWhen.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "utilities/ostream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36
0 a61af66fc99e Initial load duke parents: diff changeset	37 class AdjoiningGenerations;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	38 class CollectorPolicy;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	39 class GCHeapSummary;
0 a61af66fc99e Initial load duke parents: diff changeset	40 class GCTaskManager;
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	41 class GenerationSizer;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	42 class CollectorPolicy;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	43 class PSAdaptiveSizePolicy;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	44 class PSHeapSummary;
0 a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 class ParallelScavengeHeap : public CollectedHeap {
a61af66fc99e Initial load duke parents: diff changeset	47 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	48 private:
a61af66fc99e Initial load duke parents: diff changeset	49 static PSYoungGen* _young_gen;
a61af66fc99e Initial load duke parents: diff changeset	50 static PSOldGen* _old_gen;
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 // Sizing policy for entire heap
a61af66fc99e Initial load duke parents: diff changeset	53 static PSAdaptiveSizePolicy* _size_policy;
a61af66fc99e Initial load duke parents: diff changeset	54 static PSGCAdaptivePolicyCounters* _gc_policy_counters;
a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 static ParallelScavengeHeap* _psh;
a61af66fc99e Initial load duke parents: diff changeset	57
a61af66fc99e Initial load duke parents: diff changeset	58 size_t _young_gen_alignment;
a61af66fc99e Initial load duke parents: diff changeset	59 size_t _old_gen_alignment;
a61af66fc99e Initial load duke parents: diff changeset	60
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	61 GenerationSizer* _collector_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	62
0 a61af66fc99e Initial load duke parents: diff changeset	63 inline size_t set_alignment(size_t& var, size_t val);
a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 // Collection of generations that are adjacent in the
a61af66fc99e Initial load duke parents: diff changeset	66 // space reserved for the heap.
a61af66fc99e Initial load duke parents: diff changeset	67 AdjoiningGenerations* _gens;
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	68 unsigned int _death_march_count;
0 a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 static GCTaskManager* _gc_task_manager; // The task manager.
a61af66fc99e Initial load duke parents: diff changeset	71
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	72 void trace_heap(GCWhen::Type when, GCTracer* tracer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	73
0 a61af66fc99e Initial load duke parents: diff changeset	74 protected:
a61af66fc99e Initial load duke parents: diff changeset	75 static inline size_t total_invocations();
a61af66fc99e Initial load duke parents: diff changeset	76 HeapWord* allocate_new_tlab(size_t size);
a61af66fc99e Initial load duke parents: diff changeset	77
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	78 inline bool should_alloc_in_eden(size_t size) const;
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	79 inline void death_march_check(HeapWord* const result, size_t size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	80 HeapWord* mem_allocate_old_gen(size_t size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	81
0 a61af66fc99e Initial load duke parents: diff changeset	82 public:
a61af66fc99e Initial load duke parents: diff changeset	83 ParallelScavengeHeap() : CollectedHeap() {
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	84 _death_march_count = 0;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	85 set_alignment(_young_gen_alignment, intra_heap_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	86 set_alignment(_old_gen_alignment, intra_heap_alignment());
0 a61af66fc99e Initial load duke parents: diff changeset	87 }
a61af66fc99e Initial load duke parents: diff changeset	88
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	89 // Return the (conservative) maximum heap alignment
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	90 static size_t conservative_max_heap_alignment() {
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	91 return intra_heap_alignment();
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	92 }
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	93
0 a61af66fc99e Initial load duke parents: diff changeset	94 // For use by VM operations
a61af66fc99e Initial load duke parents: diff changeset	95 enum CollectionType {
a61af66fc99e Initial load duke parents: diff changeset	96 Scavenge,
a61af66fc99e Initial load duke parents: diff changeset	97 MarkSweep
a61af66fc99e Initial load duke parents: diff changeset	98 };
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 ParallelScavengeHeap::Name kind() const {
a61af66fc99e Initial load duke parents: diff changeset	101 return CollectedHeap::ParallelScavengeHeap;
a61af66fc99e Initial load duke parents: diff changeset	102 }
a61af66fc99e Initial load duke parents: diff changeset	103
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	104 virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) _collector_policy; }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	105
0 a61af66fc99e Initial load duke parents: diff changeset	106 static PSYoungGen* young_gen() { return _young_gen; }
a61af66fc99e Initial load duke parents: diff changeset	107 static PSOldGen* old_gen() { return _old_gen; }
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; }
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
a61af66fc99e Initial load duke parents: diff changeset	112
a61af66fc99e Initial load duke parents: diff changeset	113 static ParallelScavengeHeap* heap();
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 static GCTaskManager* const gc_task_manager() { return _gc_task_manager; }
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 AdjoiningGenerations* gens() { return _gens; }
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 // Returns JNI_OK on success
a61af66fc99e Initial load duke parents: diff changeset	120 virtual jint initialize();
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 void post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	123 void update_counters();
a61af66fc99e Initial load duke parents: diff changeset	124 // The alignment used for the various generations.
a61af66fc99e Initial load duke parents: diff changeset	125 size_t young_gen_alignment() const { return _young_gen_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	126 size_t old_gen_alignment() const { return _old_gen_alignment; }
a61af66fc99e Initial load duke parents: diff changeset	127
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	128 // The alignment used for eden and survivors within the young gen
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	129 // and for boundary between young gen and old gen.
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 10405 diff changeset	130 static size_t intra_heap_alignment() { return 64 * K * HeapWordSize; }
0 a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 size_t capacity() const;
a61af66fc99e Initial load duke parents: diff changeset	133 size_t used() const;
a61af66fc99e Initial load duke parents: diff changeset	134
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	135 // Return "true" if all generations have reached the
0 a61af66fc99e Initial load duke parents: diff changeset	136 // maximal committed limit that they can reach, without a garbage
a61af66fc99e Initial load duke parents: diff changeset	137 // collection.
a61af66fc99e Initial load duke parents: diff changeset	138 virtual bool is_maximal_no_gc() const;
a61af66fc99e Initial load duke parents: diff changeset	139
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	140 // Return true if the reference points to an object that
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	141 // can be moved in a partial collection. For currently implemented
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	142 // generational collectors that means during a collection of
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	143 // the young gen.
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	144 virtual bool is_scavengable(const void* addr);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	145
0 a61af66fc99e Initial load duke parents: diff changeset	146 // Does this heap support heap inspection? (+PrintClassHistogram)
a61af66fc99e Initial load duke parents: diff changeset	147 bool supports_heap_inspection() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 size_t max_capacity() const;
a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // Whether p is in the allocated part of the heap
a61af66fc99e Initial load duke parents: diff changeset	152 bool is_in(const void* p) const;
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 bool is_in_reserved(const void* p) const;
a61af66fc99e Initial load duke parents: diff changeset	155
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	156 #ifdef ASSERT
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	157 virtual bool is_in_partial_collection(const void *p);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	158 #endif
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	159
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	160 bool is_in_young(oop p); // reserved part
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 bool is_in_old(oop p); // reserved part
0 a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // Memory allocation. "gc_time_limit_was_exceeded" will
a61af66fc99e Initial load duke parents: diff changeset	164 // be set to true if the adaptive size policy determine that
a61af66fc99e Initial load duke parents: diff changeset	165 // an excessive amount of time is being spent doing collections
a61af66fc99e Initial load duke parents: diff changeset	166 // and caused a NULL to be returned. If a NULL is not returned,
a61af66fc99e Initial load duke parents: diff changeset	167 // "gc_time_limit_was_exceeded" has an undefined meaning.
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	168 HeapWord* mem_allocate(size_t size,
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	169 bool* gc_overhead_limit_was_exceeded);
0 a61af66fc99e Initial load duke parents: diff changeset	170
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	171 // Allocation attempt(s) during a safepoint. It should never be called
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	172 // to allocate a new TLAB as this allocation might be satisfied out
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	173 // of the old generation.
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	174 HeapWord* failed_mem_allocate(size_t size);
0 a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // Support for System.gc()
a61af66fc99e Initial load duke parents: diff changeset	177 void collect(GCCause::Cause cause);
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // These also should be called by the vm thread at a safepoint (e.g., from a
a61af66fc99e Initial load duke parents: diff changeset	180 // VM operation).
a61af66fc99e Initial load duke parents: diff changeset	181 //
a61af66fc99e Initial load duke parents: diff changeset	182 // The first collects the young generation only, unless the scavenge fails; it
a61af66fc99e Initial load duke parents: diff changeset	183 // will then attempt a full gc. The second collects the entire heap; if
a61af66fc99e Initial load duke parents: diff changeset	184 // maximum_compaction is true, it will compact everything and clear all soft
a61af66fc99e Initial load duke parents: diff changeset	185 // references.
a61af66fc99e Initial load duke parents: diff changeset	186 inline void invoke_scavenge();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	187
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	188 // Perform a full collection
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	189 virtual void do_full_collection(bool clear_all_soft_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 bool supports_inline_contig_alloc() const { return !UseNUMA; }
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 13 diff changeset	192
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 13 diff changeset	193 HeapWord top_addr() const { return !UseNUMA ? young_gen()->top_addr() : (HeapWord)-1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 13 diff changeset	194 HeapWord end_addr() const { return !UseNUMA ? young_gen()->end_addr() : (HeapWord)-1; }
0 a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 void ensure_parsability(bool retire_tlabs);
a61af66fc99e Initial load duke parents: diff changeset	197 void accumulate_statistics_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	198 void resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 size_t unsafe_max_alloc();
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 bool supports_tlab_allocation() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 size_t tlab_capacity(Thread* thr) const;
a61af66fc99e Initial load duke parents: diff changeset	205 size_t unsafe_max_tlab_alloc(Thread* thr) const;
a61af66fc99e Initial load duke parents: diff changeset	206
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	207 // Can a compiler initialize a new object without store barriers?
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	208 // This permission only extends from the creation of a new object
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	209 // via a TLAB up to the first subsequent safepoint.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	210 virtual bool can_elide_tlab_store_barriers() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	211 return true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	212 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 141 diff changeset	213
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	214 virtual bool card_mark_must_follow_store() const {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	215 return false;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	216 }
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	217
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	218 // Return true if we don't we need a store barrier for
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	219 // initializing stores to an object at this address.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	220 virtual bool can_elide_initializing_store_barrier(oop new_obj);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	221
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	222 void oop_iterate(ExtendedOopClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	223 void object_iterate(ObjectClosure* cl);
517 e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 356 diff changeset	224 void safe_object_iterate(ObjectClosure* cl) { object_iterate(cl); }
0 a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 HeapWord* block_start(const void* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	227 size_t block_size(const HeapWord* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	228 bool block_is_obj(const HeapWord* addr) const;
a61af66fc99e Initial load duke parents: diff changeset	229
a61af66fc99e Initial load duke parents: diff changeset	230 jlong millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 void prepare_for_verify();
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10369 diff changeset	233 PSHeapSummary create_ps_heap_summary();
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3774 diff changeset	234 virtual void print_on(outputStream* st) const;
9076 7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 6725 diff changeset	235 virtual void print_on_error(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	236 virtual void print_gc_threads_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	237 virtual void gc_threads_do(ThreadClosure* tc) const;
a61af66fc99e Initial load duke parents: diff changeset	238 virtual void print_tracing_info() const;
a61af66fc99e Initial load duke parents: diff changeset	239
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4914 diff changeset	240 void verify(bool silent, VerifyOption option /* ignored */);
0 a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 void print_heap_change(size_t prev_used);
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 // Resize the young generation. The reserved space for the
a61af66fc99e Initial load duke parents: diff changeset	245 // generation may be expanded in preparation for the resize.
a61af66fc99e Initial load duke parents: diff changeset	246 void resize_young_gen(size_t eden_size, size_t survivor_size);
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 // Resize the old generation. The reserved space for the
a61af66fc99e Initial load duke parents: diff changeset	249 // generation may be expanded in preparation for the resize.
a61af66fc99e Initial load duke parents: diff changeset	250 void resize_old_gen(size_t desired_free_space);
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	251
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	252 // Save the tops of the spaces in all generations
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	253 void record_gen_tops_before_GC() PRODUCT_RETURN;
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	254
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	255 // Mangle the unused parts of all spaces in the heap
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 141 diff changeset	256 void gen_mangle_unused_area() PRODUCT_RETURN;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	257
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	258 // Call these in sequential code around the processing of strong roots.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	259 class ParStrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	260 public:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	261 ParStrongRootsScope();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	262 ~ParStrongRootsScope();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	263 };
0 a61af66fc99e Initial load duke parents: diff changeset	264 };
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 inline size_t ParallelScavengeHeap::set_alignment(size_t& var, size_t val)
a61af66fc99e Initial load duke parents: diff changeset	267 {
a61af66fc99e Initial load duke parents: diff changeset	268 assert(is_power_of_2((intptr_t)val), "must be a power of 2");
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	269 var = round_to(val, intra_heap_alignment());
0 a61af66fc99e Initial load duke parents: diff changeset	270 return var;
a61af66fc99e Initial load duke parents: diff changeset	271 }
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	272
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	273 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 12233:40136aa2cdb1