truffle: src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 439f0d76cff3
children

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

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 20804:7848fc12602b