truffle: src/share/vm/gc_interface/collectedHeap.cpp annotate

annotate src/share/vm/gc_interface/collectedHeap.cpp @ 4181:319860ae697a

Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.

author	Christian Wimmer <Christian.Wimmer@Oracle.com>
date	Mon, 02 Jan 2012 14:16:08 -0800
parents	e5928e7dab26
children	3c648b9ad052

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2426 1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass trims parents: 2226 diff changeset	2 * Copyright (c) 2001, 2011, 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: 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 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: 1833 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	27 #include "gc_implementation/shared/vmGCOperations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	28 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	29 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	30 #include "oops/oop.inline.hpp"
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	31 #include "oops/instanceMirrorKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	32 #include "runtime/init.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	33 #include "services/heapDumper.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	35 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	36 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	37 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	38 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	40 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	41 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	42 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	43 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	44 # include "thread_bsd.inline.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	45 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	46
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	49 int CollectedHeap::_fire_out_of_memory_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	50 #endif
a61af66fc99e Initial load duke parents: diff changeset	51
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	52 size_t CollectedHeap::_filler_array_max_size = 0;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	53
0 a61af66fc99e Initial load duke parents: diff changeset	54 // Memory state functions.
a61af66fc99e Initial load duke parents: diff changeset	55
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1579 diff changeset	56
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1579 diff changeset	57 CollectedHeap::CollectedHeap() : _n_par_threads(0)
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1579 diff changeset	58
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	59 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	60 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	61 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	62 _filler_array_max_size = align_object_size(filler_array_hdr_size() +
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	63 max_len * elements_per_word);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	64
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	65 _barrier_set = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	66 _is_gc_active = false;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	67 _total_collections = _total_full_collections = 0;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	68 _gc_cause = _gc_lastcause = GCCause::_no_gc;
0 a61af66fc99e Initial load duke parents: diff changeset	69 NOT_PRODUCT(_promotion_failure_alot_count = 0;)
a61af66fc99e Initial load duke parents: diff changeset	70 NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 if (UsePerfData) {
a61af66fc99e Initial load duke parents: diff changeset	73 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 // create the gc cause jvmstat counters
a61af66fc99e Initial load duke parents: diff changeset	76 _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
a61af66fc99e Initial load duke parents: diff changeset	77 80, GCCause::to_string(_gc_cause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79 _perf_gc_lastcause =
a61af66fc99e Initial load duke parents: diff changeset	80 PerfDataManager::create_string_variable(SUN_GC, "lastCause",
a61af66fc99e Initial load duke parents: diff changeset	81 80, GCCause::to_string(_gc_lastcause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	82 }
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	83 _defer_initial_card_mark = false; // strengthened by subclass in pre_initialize() below.
0 a61af66fc99e Initial load duke parents: diff changeset	84 }
a61af66fc99e Initial load duke parents: diff changeset	85
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	86 void CollectedHeap::pre_initialize() {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	87 // Used for ReduceInitialCardMarks (when COMPILER2 is used);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	88 // otherwise remains unused.
1548 15190cbcabe9 6953483: Typo related to ReduceInitialCardMarks leaves concurrent collectors vulnerable to heap corruption ysr parents: 1194 diff changeset	89 #ifdef COMPILER2
1194 34fb2662f6c2 6920090: G1: Disable ReduceInitialCardMarks at least until 6920109 is fixed ysr parents: 1166 diff changeset	90 _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	91 && (DeferInitialCardMark \|\| card_mark_must_follow_store());
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	92 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	93 assert(_defer_initial_card_mark == false, "Who would set it?");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	94 #endif
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	95 }
0 a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	98 void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	99 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	100 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	101 assert(((intptr_t) (addr + slot)) != ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	102 "Found badHeapWordValue in post-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	103 }
a61af66fc99e Initial load duke parents: diff changeset	104 }
a61af66fc99e Initial load duke parents: diff changeset	105 }
a61af66fc99e Initial load duke parents: diff changeset	106
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 1972 diff changeset	107 void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size) {
0 a61af66fc99e Initial load duke parents: diff changeset	108 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	109 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	110 assert(((intptr_t) (addr + slot)) == ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	111 "Found non badHeapWordValue in pre-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	112 }
a61af66fc99e Initial load duke parents: diff changeset	113 }
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	118 void CollectedHeap::check_for_valid_allocation_state() {
a61af66fc99e Initial load duke parents: diff changeset	119 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	120 // How to choose between a pending exception and a potential
a61af66fc99e Initial load duke parents: diff changeset	121 // OutOfMemoryError? Don't allow pending exceptions.
a61af66fc99e Initial load duke parents: diff changeset	122 // This is a VM policy failure, so how do we exhaustively test it?
a61af66fc99e Initial load duke parents: diff changeset	123 assert(!thread->has_pending_exception(),
a61af66fc99e Initial load duke parents: diff changeset	124 "shouldn't be allocating with pending exception");
a61af66fc99e Initial load duke parents: diff changeset	125 if (StrictSafepointChecks) {
a61af66fc99e Initial load duke parents: diff changeset	126 assert(thread->allow_allocation(),
a61af66fc99e Initial load duke parents: diff changeset	127 "Allocation done by thread for which allocation is blocked "
a61af66fc99e Initial load duke parents: diff changeset	128 "by No_Allocation_Verifier!");
a61af66fc99e Initial load duke parents: diff changeset	129 // Allocation of an oop can always invoke a safepoint,
a61af66fc99e Initial load duke parents: diff changeset	130 // hence, the true argument
a61af66fc99e Initial load duke parents: diff changeset	131 thread->check_for_valid_safepoint_state(true);
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133 }
a61af66fc99e Initial load duke parents: diff changeset	134 #endif
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 HeapWord* CollectedHeap::allocate_from_tlab_slow(Thread* thread, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 // Retain tlab and allocate object in shared space if
a61af66fc99e Initial load duke parents: diff changeset	139 // the amount free in the tlab is too large to discard.
a61af66fc99e Initial load duke parents: diff changeset	140 if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
a61af66fc99e Initial load duke parents: diff changeset	141 thread->tlab().record_slow_allocation(size);
a61af66fc99e Initial load duke parents: diff changeset	142 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 // Discard tlab and allocate a new one.
a61af66fc99e Initial load duke parents: diff changeset	146 // To minimize fragmentation, the last TLAB may be smaller than the rest.
a61af66fc99e Initial load duke parents: diff changeset	147 size_t new_tlab_size = thread->tlab().compute_size(size);
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 thread->tlab().clear_before_allocation();
a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 if (new_tlab_size == 0) {
a61af66fc99e Initial load duke parents: diff changeset	152 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	153 }
a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 // Allocate a new TLAB...
a61af66fc99e Initial load duke parents: diff changeset	156 HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	157 if (obj == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	158 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	159 }
a61af66fc99e Initial load duke parents: diff changeset	160 if (ZeroTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	161 // ..and clear it.
a61af66fc99e Initial load duke parents: diff changeset	162 Copy::zero_to_words(obj, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	163 } else {
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	164 // ...and zap just allocated object.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	165 #ifdef ASSERT
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	166 // Skip mangling the space corresponding to the object header to
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	167 // ensure that the returned space is not considered parsable by
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	168 // any concurrent GC thread.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	169 size_t hdr_size = oopDesc::header_size();
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	170 Copy::fill_to_words(obj + hdr_size, new_tlab_size - hdr_size, badHeapWordVal);
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	171 #endif // ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173 thread->tlab().fill(obj, obj + size, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	174 return obj;
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	177 void CollectedHeap::flush_deferred_store_barrier(JavaThread* thread) {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	178 MemRegion deferred = thread->deferred_card_mark();
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	179 if (!deferred.is_empty()) {
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	180 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	181 {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	182 // 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	183 DEBUG_ONLY(oop old_obj = oop(deferred.start());)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	184 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	185 assert(!can_elide_initializing_store_barrier(old_obj),
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	186 "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	187 assert(!is_in_permanent(old_obj), "Sanity: not expected");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	188 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	189 assert(old_obj->is_parsable(), "Will not be concurrently parsable");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	190 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	191 "Mismatch: multiple objects?");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	192 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	193 BarrierSet* bs = barrier_set();
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	194 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	195 bs->write_region(deferred);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	196 // "Clear" the deferred_card_mark field
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	197 thread->set_deferred_card_mark(MemRegion());
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	198 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	199 assert(thread->deferred_card_mark().is_empty(), "invariant");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	200 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	201
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	202 // Helper for ReduceInitialCardMarks. For performance,
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	203 // 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	204 // 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	205 // compensate for such elided card-marks as follows:
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	206 // (a) Generational, non-concurrent collectors, such as
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	207 // GenCollectedHeap(ParNew,DefNew,Tenured) and
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	208 // ParallelScavengeHeap(ParallelGC, ParallelOldGC)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	209 // 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	210 // 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	211 // succeeds or precedes the initializing stores themselves,
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	212 // 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	213 // 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	214 // at the point at which we do a slow path allocation
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	215 // 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	216 // (b) GenCollectedHeap(ConcurrentMarkSweepGeneration) requires
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	217 // 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	218 // object strictly follow any associated initializing stores.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	219 // In these cases, the memRegion remembered below is
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	220 // 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	221 // 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	222 // 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	223 // (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	224 // 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	225 // card-mark.)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	226 // (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	227 // 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	228 // 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	229 // 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	230 // 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	231 // 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	232 // 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	233 // 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	234 // 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	235 // 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	236 // (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	237 // Thus, using the same protocol for maintaining the intended
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	238 // invariants turns out, serendepitously, to be the same for both
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	239 // G1 and CMS.
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	240 //
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	241 // For any future collector, this code should be reexamined with
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	242 // that specific collector in mind, and the documentation above suitably
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	243 // extended and updated.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	244 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	245 // 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	246 flush_deferred_store_barrier(thread);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	247 if (can_elide_initializing_store_barrier(new_obj)) {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	248 // The deferred_card_mark region should be empty
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	249 // following the flush above.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	250 assert(thread->deferred_card_mark().is_empty(), "Error");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	251 } else {
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	252 MemRegion mr((HeapWord*)new_obj, new_obj->size());
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	253 assert(!mr.is_empty(), "Error");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	254 if (_defer_initial_card_mark) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	255 // Defer the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	256 thread->set_deferred_card_mark(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	257 } else {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	258 // Do the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	259 BarrierSet* bs = barrier_set();
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	260 assert(bs->has_write_region_opt(), "No write_region() on BarrierSet");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	261 bs->write_region(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	262 }
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	263 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	264 return new_obj;
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	265 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	266
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	267 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	268 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	269 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	270
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	271 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	272 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	273 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	274
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	275 size_t CollectedHeap::filler_array_max_size() {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	276 return _filler_array_max_size;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	277 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	278
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	279 #ifdef ASSERT
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	280 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	281 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	282 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	283 assert(words % MinObjAlignment == 0, "unaligned size");
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	284 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	285 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	286 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	287
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	288 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	289 {
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	290 if (ZapFillerObjects && zap) {
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	291 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	292 words - filler_array_hdr_size(), 0XDEAFBABE);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	293 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	294 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	295 #endif // ASSERT
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	296
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	297 void
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	298 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	299 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	300 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	301 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	302
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	303 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	304 const size_t len = payload_size * HeapWordSize / sizeof(jint);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	305
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	306 // Set the length first for concurrent GC.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	307 ((arrayOop)start)->set_length((int)len);
494 d593294016c3 6786195: many nsk.monitoring tests fail with -server -Xcomp jcoomes parents: 481 diff changeset	308 post_allocation_setup_common(Universe::intArrayKlassObj(), start, words);
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	309 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	310 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	311
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	312 void
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	313 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	314 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	315 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	316
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	317 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	318 fill_with_array(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	319 } else if (words > 0) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	320 assert(words == min_fill_size(), "unaligned size");
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1027 diff changeset	321 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	322 words);
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
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	326 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	327 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	328 DEBUG_ONLY(fill_args_check(start, words);)
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	329 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	330 fill_with_object_impl(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	331 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	332
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	333 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	334 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	335 DEBUG_ONLY(fill_args_check(start, words);)
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	336 HandleMark hm; // Free handles before leaving.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	337
1549 1634cec09505 6953952: collectedHeap.cpp should use #ifdef _LP64 not LP64 ysr parents: 1548 diff changeset	338 #ifdef _LP64
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	339 // 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	340 // 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	341 // 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	342 const size_t min = min_fill_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	343 const size_t max = filler_array_max_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	344 while (words > max) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	345 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	346 fill_with_array(start, cur, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	347 start += cur;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	348 words -= cur;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	349 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	350 #endif
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	351
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	352 fill_with_object_impl(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	353 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	354
0 a61af66fc99e Initial load duke parents: diff changeset	355 HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	356 guarantee(false, "thread-local allocation buffers not supported");
a61af66fc99e Initial load duke parents: diff changeset	357 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 void CollectedHeap::ensure_parsability(bool retire_tlabs) {
a61af66fc99e Initial load duke parents: diff changeset	361 // The second disjunct in the assertion below makes a concession
a61af66fc99e Initial load duke parents: diff changeset	362 // for the start-up verification done while the VM is being
a61af66fc99e Initial load duke parents: diff changeset	363 // created. Callers be careful that you know that mutators
a61af66fc99e Initial load duke parents: diff changeset	364 // aren't going to interfere -- for instance, this is permissible
a61af66fc99e Initial load duke parents: diff changeset	365 // if we are still single-threaded and have either not yet
a61af66fc99e Initial load duke parents: diff changeset	366 // started allocating (nothing much to verify) or we have
a61af66fc99e Initial load duke parents: diff changeset	367 // started allocating but are now a full-fledged JavaThread
a61af66fc99e Initial load duke parents: diff changeset	368 // (and have thus made our TLAB's) available for filling.
a61af66fc99e Initial load duke parents: diff changeset	369 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	370 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	371 "Should only be called at a safepoint or at start-up"
a61af66fc99e Initial load duke parents: diff changeset	372 " otherwise concurrent mutator activity may make heap "
a61af66fc99e Initial load duke parents: diff changeset	373 " unparsable again");
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	374 const bool use_tlab = UseTLAB;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	375 const bool deferred = _defer_initial_card_mark;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	376 // The main thread starts allocating via a TLAB even before it
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	377 // has added itself to the threads list at vm boot-up.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	378 assert(!use_tlab \|\| Threads::first() != NULL,
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	379 "Attempt to fill tlabs before main thread has been added"
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	380 " to threads list is doomed to failure!");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	381 for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	382 if (use_tlab) thread->tlab().make_parsable(retire_tlabs);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	383 #ifdef COMPILER2
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	384 // The deferred store barriers must all have been flushed to the
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	385 // card-table (or other remembered set structure) before GC starts
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	386 // processing the card-table (or other remembered set).
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	387 if (deferred) flush_deferred_store_barrier(thread);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	388 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	389 assert(!deferred, "Should be false");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	390 assert(thread->deferred_card_mark().is_empty(), "Should be empty");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	391 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	392 }
a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 void CollectedHeap::accumulate_statistics_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	396 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	397 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	398 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	399 "should only accumulate statistics on tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 ThreadLocalAllocBuffer::accumulate_statistics_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	402 }
a61af66fc99e Initial load duke parents: diff changeset	403 }
a61af66fc99e Initial load duke parents: diff changeset	404
a61af66fc99e Initial load duke parents: diff changeset	405 void CollectedHeap::resize_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	406 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	407 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	408 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	409 "should only resize tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	410
a61af66fc99e Initial load duke parents: diff changeset	411 ThreadLocalAllocBuffer::resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413 }
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	414
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	415 void CollectedHeap::pre_full_gc_dump() {
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	416 if (HeapDumpBeforeFullGC) {
3869 7f776886a215 6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC ysr parents: 2426 diff changeset	417 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	418 // 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	419 // major collection has been requested.
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	420 HeapDumper::dump_heap();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	421 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	422 if (PrintClassHistogramBeforeFullGC) {
3869 7f776886a215 6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC ysr parents: 2426 diff changeset	423 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	424 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	425 inspector.doit();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	426 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	427 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	428
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	429 void CollectedHeap::post_full_gc_dump() {
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	430 if (HeapDumpAfterFullGC) {
3869 7f776886a215 6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC ysr parents: 2426 diff changeset	431 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	432 HeapDumper::dump_heap();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	433 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	434 if (PrintClassHistogramAfterFullGC) {
3869 7f776886a215 6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC ysr parents: 2426 diff changeset	435 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	436 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	437 inspector.doit();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	438 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	439 }
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	440
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	441 oop CollectedHeap::Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS) {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	442 debug_only(check_for_valid_allocation_state());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	443 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	444 assert(size >= 0, "int won't convert to size_t");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	445 HeapWord* obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	446 if (JavaObjectsInPerm) {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	447 obj = common_permanent_mem_allocate_init(size, CHECK_NULL);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	448 } else {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	449 assert(ScavengeRootsInCode > 0, "must be");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	450 obj = common_mem_allocate_init(size, CHECK_NULL);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	451 }
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	452 post_allocation_setup_common(klass, obj, size);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	453 assert(Universe::is_bootstrapping() \|\|
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	454 !((oop)obj)->blueprint()->oop_is_array(), "must not be an array");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	455 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	456 oop mirror = (oop)obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	457
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	458 java_lang_Class::set_oop_size(mirror, size);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	459
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	460 // Setup indirections
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	461 if (!real_klass.is_null()) {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	462 java_lang_Class::set_klass(mirror, real_klass());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	463 real_klass->set_java_mirror(mirror);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	464 }
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	465
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	466 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	467 assert(size == mk->instance_size(real_klass), "should have been set");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	468
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	469 // notify jvmti and dtrace
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	470 post_allocation_notify(klass, (oop)obj);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	471
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	472 return mirror;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	473 }

Mercurial > hg > truffle

annotate src/share/vm/gc_interface/collectedHeap.cpp @ 4181:319860ae697a