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

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 10369:5534bd30c151

6725714: par compact - add a table to speed up bitmap searches Reviewed-by: jmasa, tschatzl

author	jcoomes
date	Thu, 30 May 2013 13:04:51 -0700
parents	7b835924c31c
children	f2110083203d

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

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 10369:5534bd30c151