Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp @ 795:215f81b4d9b3
6841831: G1: assert(contains_reference(from),"We just added it!") fires
Summary: During parallel rset updating we have to make sure that the worker ids of the refinement threads do not intersect with the worker ids that can be claimed by the mutator threads.
Reviewed-by: tonyp
| author | iveresov |
|---|---|
| date | Mon, 18 May 2009 11:52:46 -0700 |
| parents | 0fbdb4381b99 |
| children | df6caf649ff7 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 579 | 2 * Copyright 2001-2009 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 class AdjoiningGenerations; | |
| 26 class GCTaskManager; | |
| 27 class PSAdaptiveSizePolicy; | |
| 28 | |
| 29 class ParallelScavengeHeap : public CollectedHeap { | |
| 30 friend class VMStructs; | |
| 31 private: | |
| 32 static PSYoungGen* _young_gen; | |
| 33 static PSOldGen* _old_gen; | |
| 34 static PSPermGen* _perm_gen; | |
| 35 | |
| 36 // Sizing policy for entire heap | |
| 37 static PSAdaptiveSizePolicy* _size_policy; | |
| 38 static PSGCAdaptivePolicyCounters* _gc_policy_counters; | |
| 39 | |
| 40 static ParallelScavengeHeap* _psh; | |
| 41 | |
| 42 size_t _perm_gen_alignment; | |
| 43 size_t _young_gen_alignment; | |
| 44 size_t _old_gen_alignment; | |
| 45 | |
| 46 inline size_t set_alignment(size_t& var, size_t val); | |
| 47 | |
| 48 // Collection of generations that are adjacent in the | |
| 49 // space reserved for the heap. | |
| 50 AdjoiningGenerations* _gens; | |
| 51 | |
| 52 static GCTaskManager* _gc_task_manager; // The task manager. | |
| 53 | |
| 54 protected: | |
| 55 static inline size_t total_invocations(); | |
| 56 HeapWord* allocate_new_tlab(size_t size); | |
| 57 void fill_all_tlabs(bool retire); | |
| 58 | |
| 59 public: | |
| 60 ParallelScavengeHeap() : CollectedHeap() { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
61 set_alignment(_perm_gen_alignment, intra_heap_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
62 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
|
63 set_alignment(_old_gen_alignment, intra_heap_alignment()); |
| 0 | 64 } |
| 65 | |
| 66 // For use by VM operations | |
| 67 enum CollectionType { | |
| 68 Scavenge, | |
| 69 MarkSweep | |
| 70 }; | |
| 71 | |
| 72 ParallelScavengeHeap::Name kind() const { | |
| 73 return CollectedHeap::ParallelScavengeHeap; | |
| 74 } | |
| 75 | |
| 76 static PSYoungGen* young_gen() { return _young_gen; } | |
| 77 static PSOldGen* old_gen() { return _old_gen; } | |
| 78 static PSPermGen* perm_gen() { return _perm_gen; } | |
| 79 | |
| 80 virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; } | |
| 81 | |
| 82 static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; } | |
| 83 | |
| 84 static ParallelScavengeHeap* heap(); | |
| 85 | |
| 86 static GCTaskManager* const gc_task_manager() { return _gc_task_manager; } | |
| 87 | |
| 88 AdjoiningGenerations* gens() { return _gens; } | |
| 89 | |
| 90 // Returns JNI_OK on success | |
| 91 virtual jint initialize(); | |
| 92 | |
| 93 void post_initialize(); | |
| 94 void update_counters(); | |
| 95 // The alignment used for the various generations. | |
| 96 size_t perm_gen_alignment() const { return _perm_gen_alignment; } | |
| 97 size_t young_gen_alignment() const { return _young_gen_alignment; } | |
| 98 size_t old_gen_alignment() const { return _old_gen_alignment; } | |
| 99 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
100 // 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
|
101 // and for boundary between young gen and old gen. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
102 size_t intra_heap_alignment() const { return 64 * K; } |
| 0 | 103 |
| 104 size_t capacity() const; | |
| 105 size_t used() const; | |
| 106 | |
| 107 // Return "true" if all generations (but perm) have reached the | |
| 108 // maximal committed limit that they can reach, without a garbage | |
| 109 // collection. | |
| 110 virtual bool is_maximal_no_gc() const; | |
| 111 | |
| 112 // Does this heap support heap inspection? (+PrintClassHistogram) | |
| 113 bool supports_heap_inspection() const { return true; } | |
| 114 | |
| 115 size_t permanent_capacity() const; | |
| 116 size_t permanent_used() const; | |
| 117 | |
| 118 size_t max_capacity() const; | |
| 119 | |
| 120 // Whether p is in the allocated part of the heap | |
| 121 bool is_in(const void* p) const; | |
| 122 | |
| 123 bool is_in_reserved(const void* p) const; | |
| 124 bool is_in_permanent(const void *p) const { // reserved part | |
| 125 return perm_gen()->reserved().contains(p); | |
| 126 } | |
| 127 | |
| 128 bool is_permanent(const void *p) const { // committed part | |
| 129 return perm_gen()->is_in(p); | |
| 130 } | |
| 131 | |
| 132 static bool is_in_young(oop *p); // reserved part | |
| 133 static bool is_in_old_or_perm(oop *p); // reserved part | |
| 134 | |
| 135 // Memory allocation. "gc_time_limit_was_exceeded" will | |
| 136 // be set to true if the adaptive size policy determine that | |
| 137 // an excessive amount of time is being spent doing collections | |
| 138 // and caused a NULL to be returned. If a NULL is not returned, | |
| 139 // "gc_time_limit_was_exceeded" has an undefined meaning. | |
| 140 | |
| 141 HeapWord* mem_allocate(size_t size, | |
| 142 bool is_noref, | |
| 143 bool is_tlab, | |
| 144 bool* gc_overhead_limit_was_exceeded); | |
| 145 HeapWord* failed_mem_allocate(size_t size, bool is_tlab); | |
| 146 | |
| 147 HeapWord* permanent_mem_allocate(size_t size); | |
| 148 HeapWord* failed_permanent_mem_allocate(size_t size); | |
| 149 | |
| 150 // Support for System.gc() | |
| 151 void collect(GCCause::Cause cause); | |
| 152 | |
| 153 // This interface assumes that it's being called by the | |
| 154 // vm thread. It collects the heap assuming that the | |
| 155 // heap lock is already held and that we are executing in | |
| 156 // the context of the vm thread. | |
| 157 void collect_as_vm_thread(GCCause::Cause cause); | |
| 158 | |
| 159 // These also should be called by the vm thread at a safepoint (e.g., from a | |
| 160 // VM operation). | |
| 161 // | |
| 162 // The first collects the young generation only, unless the scavenge fails; it | |
| 163 // will then attempt a full gc. The second collects the entire heap; if | |
| 164 // maximum_compaction is true, it will compact everything and clear all soft | |
| 165 // references. | |
| 166 inline void invoke_scavenge(); | |
| 167 inline void invoke_full_gc(bool maximum_compaction); | |
| 168 | |
| 169 size_t large_typearray_limit() { return FastAllocateSizeLimit; } | |
| 170 | |
| 171 bool supports_inline_contig_alloc() const { return !UseNUMA; } | |
| 141 | 172 |
| 173 HeapWord** top_addr() const { return !UseNUMA ? young_gen()->top_addr() : (HeapWord**)-1; } | |
| 174 HeapWord** end_addr() const { return !UseNUMA ? young_gen()->end_addr() : (HeapWord**)-1; } | |
| 0 | 175 |
| 176 void ensure_parsability(bool retire_tlabs); | |
| 177 void accumulate_statistics_all_tlabs(); | |
| 178 void resize_all_tlabs(); | |
| 179 | |
| 180 size_t unsafe_max_alloc(); | |
| 181 | |
| 182 bool supports_tlab_allocation() const { return true; } | |
| 183 | |
| 184 size_t tlab_capacity(Thread* thr) const; | |
| 185 size_t unsafe_max_tlab_alloc(Thread* thr) const; | |
| 186 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
187 // Can a compiler initialize a new object without store barriers? |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
188 // 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
|
189 // via a TLAB up to the first subsequent safepoint. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
190 virtual bool can_elide_tlab_store_barriers() const { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
191 return true; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
192 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
193 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
194 // Can a compiler elide a store barrier when it writes |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
195 // a permanent oop into the heap? Applies when the compiler |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
196 // is storing x to the heap, where x->is_perm() is true. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
197 virtual bool can_elide_permanent_oop_store_barriers() const { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
198 return true; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
199 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
200 |
| 0 | 201 void oop_iterate(OopClosure* cl); |
| 202 void object_iterate(ObjectClosure* cl); | |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
203 void safe_object_iterate(ObjectClosure* cl) { object_iterate(cl); } |
| 0 | 204 void permanent_oop_iterate(OopClosure* cl); |
| 205 void permanent_object_iterate(ObjectClosure* cl); | |
| 206 | |
| 207 HeapWord* block_start(const void* addr) const; | |
| 208 size_t block_size(const HeapWord* addr) const; | |
| 209 bool block_is_obj(const HeapWord* addr) const; | |
| 210 | |
| 211 jlong millis_since_last_gc(); | |
| 212 | |
| 213 void prepare_for_verify(); | |
| 214 void print() const; | |
| 215 void print_on(outputStream* st) const; | |
| 216 virtual void print_gc_threads_on(outputStream* st) const; | |
| 217 virtual void gc_threads_do(ThreadClosure* tc) const; | |
| 218 virtual void print_tracing_info() const; | |
| 219 | |
| 220 void verify(bool allow_dirty, bool silent); | |
| 221 | |
| 222 void print_heap_change(size_t prev_used); | |
| 223 | |
| 224 // Resize the young generation. The reserved space for the | |
| 225 // generation may be expanded in preparation for the resize. | |
| 226 void resize_young_gen(size_t eden_size, size_t survivor_size); | |
| 227 | |
| 228 // Resize the old generation. The reserved space for the | |
| 229 // generation may be expanded in preparation for the resize. | |
| 230 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
|
231 |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
141
diff
changeset
|
232 // 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
|
233 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
|
234 |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
141
diff
changeset
|
235 // 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
|
236 void gen_mangle_unused_area() PRODUCT_RETURN; |
| 0 | 237 }; |
| 238 | |
| 239 inline size_t ParallelScavengeHeap::set_alignment(size_t& var, size_t val) | |
| 240 { | |
| 241 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
|
242 var = round_to(val, intra_heap_alignment()); |
| 0 | 243 return var; |
| 244 } |