Mercurial > hg > graal-compiler
annotate src/share/vm/gc_interface/collectedHeap.cpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
author | coleenp |
---|---|
date | Wed, 20 Mar 2013 08:04:54 -0400 |
parents | f34d701e952e |
children | f2110083203d |
rev | line source |
---|---|
0 | 1 /* |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1549
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1549
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:
1549
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/systemDictionary.hpp" | |
27 #include "gc_implementation/shared/vmGCOperations.hpp" | |
28 #include "gc_interface/collectedHeap.hpp" | |
29 #include "gc_interface/collectedHeap.inline.hpp" | |
30 #include "oops/oop.inline.hpp" | |
4009 | 31 #include "oops/instanceMirrorKlass.hpp" |
1972 | 32 #include "runtime/init.hpp" |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6735
diff
changeset
|
33 #include "runtime/thread.inline.hpp" |
1972 | 34 #include "services/heapDumper.hpp" |
0 | 35 |
36 | |
37 #ifdef ASSERT | |
38 int CollectedHeap::_fire_out_of_memory_count = 0; | |
39 #endif | |
40 | |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
41 size_t CollectedHeap::_filler_array_max_size = 0; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
42 |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
43 template <> |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
44 void EventLogBase<GCMessage>::print(outputStream* st, GCMessage& m) { |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
45 st->print_cr("GC heap %s", m.is_before ? "before" : "after"); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
46 st->print_raw(m); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
47 } |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
48 |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
49 void GCHeapLog::log_heap(bool before) { |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
50 if (!should_log()) { |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
51 return; |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
52 } |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
53 |
4944 | 54 double timestamp = fetch_timestamp(); |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
55 MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
56 int index = compute_log_index(); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
57 _records[index].thread = NULL; // Its the GC thread so it's not that interesting. |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
58 _records[index].timestamp = timestamp; |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
59 _records[index].data.is_before = before; |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
60 stringStream st(_records[index].data.buffer(), _records[index].data.size()); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
61 if (before) { |
4944 | 62 Universe::print_heap_before_gc(&st, true); |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
63 } else { |
4944 | 64 Universe::print_heap_after_gc(&st, true); |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
65 } |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
66 } |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
67 |
0 | 68 // Memory state functions. |
69 | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1579
diff
changeset
|
70 |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1579
diff
changeset
|
71 CollectedHeap::CollectedHeap() : _n_par_threads(0) |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1579
diff
changeset
|
72 |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
73 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
74 const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT)); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
75 const size_t elements_per_word = HeapWordSize / sizeof(jint); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
76 _filler_array_max_size = align_object_size(filler_array_hdr_size() + |
5965
cc74fa5a91a9
7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents:
4944
diff
changeset
|
77 max_len / elements_per_word); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
78 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
79 _barrier_set = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
80 _is_gc_active = false; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
81 _total_collections = _total_full_collections = 0; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
82 _gc_cause = _gc_lastcause = GCCause::_no_gc; |
0 | 83 NOT_PRODUCT(_promotion_failure_alot_count = 0;) |
84 NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;) | |
85 | |
86 if (UsePerfData) { | |
87 EXCEPTION_MARK; | |
88 | |
89 // create the gc cause jvmstat counters | |
90 _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause", | |
91 80, GCCause::to_string(_gc_cause), CHECK); | |
92 | |
93 _perf_gc_lastcause = | |
94 PerfDataManager::create_string_variable(SUN_GC, "lastCause", | |
95 80, GCCause::to_string(_gc_lastcause), CHECK); | |
96 } | |
1166 | 97 _defer_initial_card_mark = false; // strengthened by subclass in pre_initialize() below. |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
98 // Create the ring log |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
99 if (LogEvents) { |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
100 _gc_heap_log = new GCHeapLog(); |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
101 } else { |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
102 _gc_heap_log = NULL; |
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4746
diff
changeset
|
103 } |
0 | 104 } |
105 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
106 // This interface assumes that it's being called by the |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
107 // vm thread. It collects the heap assuming that the |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
108 // heap lock is already held and that we are executing in |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
109 // the context of the vm thread. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
110 void CollectedHeap::collect_as_vm_thread(GCCause::Cause cause) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
111 assert(Thread::current()->is_VM_thread(), "Precondition#1"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
112 assert(Heap_lock->is_locked(), "Precondition#2"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
113 GCCauseSetter gcs(this, cause); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
114 switch (cause) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
115 case GCCause::_heap_inspection: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
116 case GCCause::_heap_dump: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
117 case GCCause::_metadata_GC_threshold : { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
118 HandleMark hm; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
119 do_full_collection(false); // don't clear all soft refs |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
120 break; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
121 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
122 case GCCause::_last_ditch_collection: { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
123 HandleMark hm; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
124 do_full_collection(true); // do clear all soft refs |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
125 break; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
126 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
127 default: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
128 ShouldNotReachHere(); // Unexpected use of this function |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
129 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
130 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
131 MetaWord* CollectedHeap::satisfy_failed_metadata_allocation( |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
132 ClassLoaderData* loader_data, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
133 size_t size, Metaspace::MetadataType mdtype) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
134 return collector_policy()->satisfy_failed_metadata_allocation(loader_data, size, mdtype); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
135 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
136 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
137 |
1166 | 138 void CollectedHeap::pre_initialize() { |
139 // Used for ReduceInitialCardMarks (when COMPILER2 is used); | |
140 // otherwise remains unused. | |
1548
15190cbcabe9
6953483: Typo related to ReduceInitialCardMarks leaves concurrent collectors vulnerable to heap corruption
ysr
parents:
1194
diff
changeset
|
141 #ifdef COMPILER2 |
1194
34fb2662f6c2
6920090: G1: Disable ReduceInitialCardMarks at least until 6920109 is fixed
ysr
parents:
1166
diff
changeset
|
142 _defer_initial_card_mark = ReduceInitialCardMarks && can_elide_tlab_store_barriers() |
34fb2662f6c2
6920090: G1: Disable ReduceInitialCardMarks at least until 6920109 is fixed
ysr
parents:
1166
diff
changeset
|
143 && (DeferInitialCardMark || card_mark_must_follow_store()); |
1166 | 144 #else |
145 assert(_defer_initial_card_mark == false, "Who would set it?"); | |
146 #endif | |
147 } | |
0 | 148 |
149 #ifndef PRODUCT | |
150 void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) { | |
151 if (CheckMemoryInitialization && ZapUnusedHeapArea) { | |
152 for (size_t slot = 0; slot < size; slot += 1) { | |
153 assert((*(intptr_t*) (addr + slot)) != ((intptr_t) badHeapWordVal), | |
154 "Found badHeapWordValue in post-allocation check"); | |
155 } | |
156 } | |
157 } | |
158 | |
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
159 void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size) { |
0 | 160 if (CheckMemoryInitialization && ZapUnusedHeapArea) { |
161 for (size_t slot = 0; slot < size; slot += 1) { | |
162 assert((*(intptr_t*) (addr + slot)) == ((intptr_t) badHeapWordVal), | |
163 "Found non badHeapWordValue in pre-allocation check"); | |
164 } | |
165 } | |
166 } | |
167 #endif // PRODUCT | |
168 | |
169 #ifdef ASSERT | |
170 void CollectedHeap::check_for_valid_allocation_state() { | |
171 Thread *thread = Thread::current(); | |
172 // How to choose between a pending exception and a potential | |
173 // OutOfMemoryError? Don't allow pending exceptions. | |
174 // This is a VM policy failure, so how do we exhaustively test it? | |
175 assert(!thread->has_pending_exception(), | |
176 "shouldn't be allocating with pending exception"); | |
177 if (StrictSafepointChecks) { | |
178 assert(thread->allow_allocation(), | |
179 "Allocation done by thread for which allocation is blocked " | |
180 "by No_Allocation_Verifier!"); | |
181 // Allocation of an oop can always invoke a safepoint, | |
182 // hence, the true argument | |
183 thread->check_for_valid_safepoint_state(true); | |
184 } | |
185 } | |
186 #endif | |
187 | |
188 HeapWord* CollectedHeap::allocate_from_tlab_slow(Thread* thread, size_t size) { | |
189 | |
190 // Retain tlab and allocate object in shared space if | |
191 // the amount free in the tlab is too large to discard. | |
192 if (thread->tlab().free() > thread->tlab().refill_waste_limit()) { | |
193 thread->tlab().record_slow_allocation(size); | |
194 return NULL; | |
195 } | |
196 | |
197 // Discard tlab and allocate a new one. | |
198 // To minimize fragmentation, the last TLAB may be smaller than the rest. | |
199 size_t new_tlab_size = thread->tlab().compute_size(size); | |
200 | |
201 thread->tlab().clear_before_allocation(); | |
202 | |
203 if (new_tlab_size == 0) { | |
204 return NULL; | |
205 } | |
206 | |
207 // Allocate a new TLAB... | |
208 HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size); | |
209 if (obj == NULL) { | |
210 return NULL; | |
211 } | |
212 if (ZeroTLAB) { | |
213 // ..and clear it. | |
214 Copy::zero_to_words(obj, new_tlab_size); | |
215 } else { | |
3892 | 216 // ...and zap just allocated object. |
217 #ifdef ASSERT | |
218 // Skip mangling the space corresponding to the object header to | |
219 // ensure that the returned space is not considered parsable by | |
220 // any concurrent GC thread. | |
221 size_t hdr_size = oopDesc::header_size(); | |
222 Copy::fill_to_words(obj + hdr_size, new_tlab_size - hdr_size, badHeapWordVal); | |
223 #endif // ASSERT | |
0 | 224 } |
225 thread->tlab().fill(obj, obj + size, new_tlab_size); | |
226 return obj; | |
227 } | |
228 | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
229 void CollectedHeap::flush_deferred_store_barrier(JavaThread* thread) { |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
230 MemRegion deferred = thread->deferred_card_mark(); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
231 if (!deferred.is_empty()) { |
1166 | 232 assert(_defer_initial_card_mark, "Otherwise should be empty"); |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
233 { |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
234 // Verify that the storage points to a parsable object in heap |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
235 DEBUG_ONLY(oop old_obj = oop(deferred.start());) |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
236 assert(is_in(old_obj), "Not in allocated heap"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
237 assert(!can_elide_initializing_store_barrier(old_obj), |
1166 | 238 "Else should have been filtered in new_store_pre_barrier()"); |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
239 assert(old_obj->is_oop(true), "Not an oop"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
240 assert(deferred.word_size() == (size_t)(old_obj->size()), |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
241 "Mismatch: multiple objects?"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
242 } |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
243 BarrierSet* bs = barrier_set(); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
244 assert(bs->has_write_region_opt(), "No write_region() on BarrierSet"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
245 bs->write_region(deferred); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
246 // "Clear" the deferred_card_mark field |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
247 thread->set_deferred_card_mark(MemRegion()); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
248 } |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
249 assert(thread->deferred_card_mark().is_empty(), "invariant"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
250 } |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
251 |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
252 // Helper for ReduceInitialCardMarks. For performance, |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
253 // compiled code may elide card-marks for initializing stores |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
254 // to a newly allocated object along the fast-path. We |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
255 // compensate for such elided card-marks as follows: |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
256 // (a) Generational, non-concurrent collectors, such as |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
257 // GenCollectedHeap(ParNew,DefNew,Tenured) and |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
258 // ParallelScavengeHeap(ParallelGC, ParallelOldGC) |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
259 // need the card-mark if and only if the region is |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
260 // in the old gen, and do not care if the card-mark |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
261 // succeeds or precedes the initializing stores themselves, |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
262 // so long as the card-mark is completed before the next |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
263 // scavenge. For all these cases, we can do a card mark |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
264 // at the point at which we do a slow path allocation |
1166 | 265 // in the old gen, i.e. in this call. |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
266 // (b) GenCollectedHeap(ConcurrentMarkSweepGeneration) requires |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
267 // in addition that the card-mark for an old gen allocated |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
268 // object strictly follow any associated initializing stores. |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
269 // In these cases, the memRegion remembered below is |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
270 // used to card-mark the entire region either just before the next |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
271 // slow-path allocation by this thread or just before the next scavenge or |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
272 // CMS-associated safepoint, whichever of these events happens first. |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
273 // (The implicit assumption is that the object has been fully |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
274 // initialized by this point, a fact that we assert when doing the |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
275 // card-mark.) |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
276 // (c) G1CollectedHeap(G1) uses two kinds of write barriers. When a |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
277 // G1 concurrent marking is in progress an SATB (pre-write-)barrier is |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
278 // is used to remember the pre-value of any store. Initializing |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
279 // stores will not need this barrier, so we need not worry about |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
280 // compensating for the missing pre-barrier here. Turning now |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
281 // to the post-barrier, we note that G1 needs a RS update barrier |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
282 // which simply enqueues a (sequence of) dirty cards which may |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
283 // optionally be refined by the concurrent update threads. Note |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
284 // that this barrier need only be applied to a non-young write, |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
285 // but, like in CMS, because of the presence of concurrent refinement |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
286 // (much like CMS' precleaning), must strictly follow the oop-store. |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
287 // Thus, using the same protocol for maintaining the intended |
1166 | 288 // invariants turns out, serendepitously, to be the same for both |
289 // G1 and CMS. | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
290 // |
1166 | 291 // For any future collector, this code should be reexamined with |
292 // that specific collector in mind, and the documentation above suitably | |
293 // extended and updated. | |
294 oop CollectedHeap::new_store_pre_barrier(JavaThread* thread, oop new_obj) { | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
295 // If a previous card-mark was deferred, flush it now. |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
296 flush_deferred_store_barrier(thread); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
297 if (can_elide_initializing_store_barrier(new_obj)) { |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
298 // The deferred_card_mark region should be empty |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
299 // following the flush above. |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
300 assert(thread->deferred_card_mark().is_empty(), "Error"); |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
301 } else { |
1166 | 302 MemRegion mr((HeapWord*)new_obj, new_obj->size()); |
303 assert(!mr.is_empty(), "Error"); | |
304 if (_defer_initial_card_mark) { | |
305 // Defer the card mark | |
306 thread->set_deferred_card_mark(mr); | |
307 } else { | |
308 // Do the card mark | |
309 BarrierSet* bs = barrier_set(); | |
310 assert(bs->has_write_region_opt(), "No write_region() on BarrierSet"); | |
311 bs->write_region(mr); | |
312 } | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
313 } |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
314 return new_obj; |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
315 } |
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
628
diff
changeset
|
316 |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
317 size_t CollectedHeap::filler_array_hdr_size() { |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1549
diff
changeset
|
318 return size_t(align_object_offset(arrayOopDesc::header_size(T_INT))); // align to Long |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
319 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
320 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
321 size_t CollectedHeap::filler_array_min_size() { |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1549
diff
changeset
|
322 return align_object_size(filler_array_hdr_size()); // align to MinObjAlignment |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
323 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
324 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
325 #ifdef ASSERT |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
326 void CollectedHeap::fill_args_check(HeapWord* start, size_t words) |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
327 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
328 assert(words >= min_fill_size(), "too small to fill"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
329 assert(words % MinObjAlignment == 0, "unaligned size"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
330 assert(Universe::heap()->is_in_reserved(start), "not in heap"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
331 assert(Universe::heap()->is_in_reserved(start + words - 1), "not in heap"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
332 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
333 |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
334 void CollectedHeap::zap_filler_array(HeapWord* start, size_t words, bool zap) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
335 { |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
336 if (ZapFillerObjects && zap) { |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
337 Copy::fill_to_words(start + filler_array_hdr_size(), |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
338 words - filler_array_hdr_size(), 0XDEAFBABE); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
339 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
340 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
341 #endif // ASSERT |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
342 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
343 void |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
344 CollectedHeap::fill_with_array(HeapWord* start, size_t words, bool zap) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
345 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
346 assert(words >= filler_array_min_size(), "too small for an array"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
347 assert(words <= filler_array_max_size(), "too big for a single object"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
348 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
349 const size_t payload_size = words - filler_array_hdr_size(); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
350 const size_t len = payload_size * HeapWordSize / sizeof(jint); |
5965
cc74fa5a91a9
7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents:
4944
diff
changeset
|
351 assert((int)len >= 0, err_msg("size too large " SIZE_FORMAT " becomes %d", words, (int)len)); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
352 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
353 // Set the length first for concurrent GC. |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
354 ((arrayOop)start)->set_length((int)len); |
5972
9a9bb0010c91
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
5965
diff
changeset
|
355 post_allocation_setup_common(Universe::intArrayKlassObj(), start); |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
356 DEBUG_ONLY(zap_filler_array(start, words, zap);) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
357 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
358 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
359 void |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
360 CollectedHeap::fill_with_object_impl(HeapWord* start, size_t words, bool zap) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
361 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
362 assert(words <= filler_array_max_size(), "too big for a single object"); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
363 |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
364 if (words >= filler_array_min_size()) { |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
365 fill_with_array(start, words, zap); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
366 } else if (words > 0) { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
367 assert(words == min_fill_size(), "unaligned size"); |
5972
9a9bb0010c91
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
5965
diff
changeset
|
368 post_allocation_setup_common(SystemDictionary::Object_klass(), start); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
369 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
370 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
371 |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
372 void CollectedHeap::fill_with_object(HeapWord* start, size_t words, bool zap) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
373 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
374 DEBUG_ONLY(fill_args_check(start, words);) |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
375 HandleMark hm; // Free handles before leaving. |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
376 fill_with_object_impl(start, words, zap); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
377 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
378 |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
379 void CollectedHeap::fill_with_objects(HeapWord* start, size_t words, bool zap) |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
380 { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
381 DEBUG_ONLY(fill_args_check(start, words);) |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
382 HandleMark hm; // Free handles before leaving. |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
383 |
1549
1634cec09505
6953952: collectedHeap.cpp should use #ifdef _LP64 not LP64
ysr
parents:
1548
diff
changeset
|
384 #ifdef _LP64 |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
385 // A single array can fill ~8G, so multiple objects are needed only in 64-bit. |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
386 // First fill with arrays, ensuring that any remaining space is big enough to |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
387 // fill. The remainder is filled with a single object. |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
388 const size_t min = min_fill_size(); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
389 const size_t max = filler_array_max_size(); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
390 while (words > max) { |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
391 const size_t cur = words - max >= min ? max : max - min; |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
392 fill_with_array(start, cur, zap); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
393 start += cur; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
394 words -= cur; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
395 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
396 #endif |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
397 |
1165
2dd52dea6d28
6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents:
1142
diff
changeset
|
398 fill_with_object_impl(start, words, zap); |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
399 } |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
356
diff
changeset
|
400 |
0 | 401 HeapWord* CollectedHeap::allocate_new_tlab(size_t size) { |
402 guarantee(false, "thread-local allocation buffers not supported"); | |
403 return NULL; | |
404 } | |
405 | |
406 void CollectedHeap::ensure_parsability(bool retire_tlabs) { | |
407 // The second disjunct in the assertion below makes a concession | |
408 // for the start-up verification done while the VM is being | |
409 // created. Callers be careful that you know that mutators | |
410 // aren't going to interfere -- for instance, this is permissible | |
411 // if we are still single-threaded and have either not yet | |
412 // started allocating (nothing much to verify) or we have | |
413 // started allocating but are now a full-fledged JavaThread | |
414 // (and have thus made our TLAB's) available for filling. | |
415 assert(SafepointSynchronize::is_at_safepoint() || | |
416 !is_init_completed(), | |
417 "Should only be called at a safepoint or at start-up" | |
418 " otherwise concurrent mutator activity may make heap " | |
419 " unparsable again"); | |
1166 | 420 const bool use_tlab = UseTLAB; |
421 const bool deferred = _defer_initial_card_mark; | |
422 // The main thread starts allocating via a TLAB even before it | |
423 // has added itself to the threads list at vm boot-up. | |
424 assert(!use_tlab || Threads::first() != NULL, | |
425 "Attempt to fill tlabs before main thread has been added" | |
426 " to threads list is doomed to failure!"); | |
427 for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) { | |
428 if (use_tlab) thread->tlab().make_parsable(retire_tlabs); | |
429 #ifdef COMPILER2 | |
430 // The deferred store barriers must all have been flushed to the | |
431 // card-table (or other remembered set structure) before GC starts | |
432 // processing the card-table (or other remembered set). | |
433 if (deferred) flush_deferred_store_barrier(thread); | |
434 #else | |
435 assert(!deferred, "Should be false"); | |
436 assert(thread->deferred_card_mark().is_empty(), "Should be empty"); | |
437 #endif | |
0 | 438 } |
439 } | |
440 | |
441 void CollectedHeap::accumulate_statistics_all_tlabs() { | |
442 if (UseTLAB) { | |
443 assert(SafepointSynchronize::is_at_safepoint() || | |
444 !is_init_completed(), | |
445 "should only accumulate statistics on tlabs at safepoint"); | |
446 | |
447 ThreadLocalAllocBuffer::accumulate_statistics_before_gc(); | |
448 } | |
449 } | |
450 | |
451 void CollectedHeap::resize_all_tlabs() { | |
452 if (UseTLAB) { | |
453 assert(SafepointSynchronize::is_at_safepoint() || | |
454 !is_init_completed(), | |
455 "should only resize tlabs at safepoint"); | |
456 | |
457 ThreadLocalAllocBuffer::resize_all_tlabs(); | |
458 } | |
459 } | |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
460 |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
461 void CollectedHeap::pre_full_gc_dump() { |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
462 if (HeapDumpBeforeFullGC) { |
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
2426
diff
changeset
|
463 TraceTime tt("Heap Dump (before full gc): ", PrintGCDetails, false, gclog_or_tty); |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
464 // We are doing a "major" collection and a heap dump before |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
465 // major collection has been requested. |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
466 HeapDumper::dump_heap(); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
467 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
468 if (PrintClassHistogramBeforeFullGC) { |
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
2426
diff
changeset
|
469 TraceTime tt("Class Histogram (before full gc): ", PrintGCDetails, true, gclog_or_tty); |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
470 VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */, false /* ! prologue */); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
471 inspector.doit(); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
472 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
473 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
474 |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
475 void CollectedHeap::post_full_gc_dump() { |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
476 if (HeapDumpAfterFullGC) { |
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
2426
diff
changeset
|
477 TraceTime tt("Heap Dump (after full gc): ", PrintGCDetails, false, gclog_or_tty); |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
478 HeapDumper::dump_heap(); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
479 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
480 if (PrintClassHistogramAfterFullGC) { |
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
2426
diff
changeset
|
481 TraceTime tt("Class Histogram (after full gc): ", PrintGCDetails, true, gclog_or_tty); |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
482 VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */, false /* ! prologue */); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
483 inspector.doit(); |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
484 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
494
diff
changeset
|
485 } |
4009 | 486 |
487 oop CollectedHeap::Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS) { | |
488 debug_only(check_for_valid_allocation_state()); | |
489 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); | |
490 assert(size >= 0, "int won't convert to size_t"); | |
491 HeapWord* obj; | |
492 assert(ScavengeRootsInCode > 0, "must be"); | |
493 obj = common_mem_allocate_init(size, CHECK_NULL); | |
5972
9a9bb0010c91
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
5965
diff
changeset
|
494 post_allocation_setup_common(klass, obj); |
4009 | 495 assert(Universe::is_bootstrapping() || |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
5972
diff
changeset
|
496 !((oop)obj)->is_array(), "must not be an array"); |
4009 | 497 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); |
498 oop mirror = (oop)obj; | |
499 | |
500 java_lang_Class::set_oop_size(mirror, size); | |
501 | |
502 // Setup indirections | |
503 if (!real_klass.is_null()) { | |
504 java_lang_Class::set_klass(mirror, real_klass()); | |
505 real_klass->set_java_mirror(mirror); | |
506 } | |
507 | |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
508 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass()); |
4009 | 509 assert(size == mk->instance_size(real_klass), "should have been set"); |
510 | |
511 // notify jvmti and dtrace | |
512 post_allocation_notify(klass, (oop)obj); | |
513 | |
514 return mirror; | |
515 } | |
4708 | 516 |
517 /////////////// Unit tests /////////////// | |
518 | |
519 #ifndef PRODUCT | |
520 void CollectedHeap::test_is_in() { | |
521 CollectedHeap* heap = Universe::heap(); | |
522 | |
4746
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
523 uintptr_t epsilon = (uintptr_t) MinObjAlignment; |
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
524 uintptr_t heap_start = (uintptr_t) heap->_reserved.start(); |
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
525 uintptr_t heap_end = (uintptr_t) heap->_reserved.end(); |
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
526 |
4708 | 527 // Test that NULL is not in the heap. |
528 assert(!heap->is_in(NULL), "NULL is unexpectedly in the heap"); | |
529 | |
530 // Test that a pointer to before the heap start is reported as outside the heap. | |
4746
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
531 assert(heap_start >= ((uintptr_t)NULL + epsilon), "sanity"); |
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
532 void* before_heap = (void*)(heap_start - epsilon); |
4708 | 533 assert(!heap->is_in(before_heap), |
534 err_msg("before_heap: " PTR_FORMAT " is unexpectedly in the heap", before_heap)); | |
535 | |
536 // Test that a pointer to after the heap end is reported as outside the heap. | |
4746
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
537 assert(heap_end <= ((uintptr_t)-1 - epsilon), "sanity"); |
b6a04c79ccbc
7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1
stefank
parents:
4708
diff
changeset
|
538 void* after_heap = (void*)(heap_end + epsilon); |
4708 | 539 assert(!heap->is_in(after_heap), |
540 err_msg("after_heap: " PTR_FORMAT " is unexpectedly in the heap", after_heap)); | |
541 } | |
542 #endif |