graal-compiler: src/share/vm/gc_interface/collectedHeap.cpp annotate

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 a61af66fc99e Initial load duke parents: diff changeset	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 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"
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6735 diff changeset	33 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #include "services/heapDumper.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	38 int CollectedHeap::_fire_out_of_memory_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	39 #endif
a61af66fc99e Initial load duke parents: diff changeset	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 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	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 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	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 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	68 // Memory state functions.
a61af66fc99e Initial load duke parents: diff changeset	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: HeapWordParallelScavengeHeap::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 a61af66fc99e Initial load duke parents: diff changeset	83 NOT_PRODUCT(_promotion_failure_alot_count = 0;)
a61af66fc99e Initial load duke parents: diff changeset	84 NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
a61af66fc99e Initial load duke parents: diff changeset	85
a61af66fc99e Initial load duke parents: diff changeset	86 if (UsePerfData) {
a61af66fc99e Initial load duke parents: diff changeset	87 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	88
a61af66fc99e Initial load duke parents: diff changeset	89 // create the gc cause jvmstat counters
a61af66fc99e Initial load duke parents: diff changeset	90 _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
a61af66fc99e Initial load duke parents: diff changeset	91 80, GCCause::to_string(_gc_cause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 _perf_gc_lastcause =
a61af66fc99e Initial load duke parents: diff changeset	94 PerfDataManager::create_string_variable(SUN_GC, "lastCause",
a61af66fc99e Initial load duke parents: diff changeset	95 80, GCCause::to_string(_gc_lastcause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	96 }
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	104 }
a61af66fc99e Initial load duke parents: diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	138 void CollectedHeap::pre_initialize() {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	139 // Used for ReduceInitialCardMarks (when COMPILER2 is used);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	144 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	145 assert(_defer_initial_card_mark == false, "Who would set it?");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	146 #endif
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	147 }
0 a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	150 void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	151 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	152 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	153 assert(((intptr_t) (addr + slot)) != ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	154 "Found badHeapWordValue in post-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	160 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	161 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	162 assert(((intptr_t) (addr + slot)) == ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	163 "Found non badHeapWordValue in pre-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	164 }
a61af66fc99e Initial load duke parents: diff changeset	165 }
a61af66fc99e Initial load duke parents: diff changeset	166 }
a61af66fc99e Initial load duke parents: diff changeset	167 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	170 void CollectedHeap::check_for_valid_allocation_state() {
a61af66fc99e Initial load duke parents: diff changeset	171 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	172 // How to choose between a pending exception and a potential
a61af66fc99e Initial load duke parents: diff changeset	173 // OutOfMemoryError? Don't allow pending exceptions.
a61af66fc99e Initial load duke parents: diff changeset	174 // This is a VM policy failure, so how do we exhaustively test it?
a61af66fc99e Initial load duke parents: diff changeset	175 assert(!thread->has_pending_exception(),
a61af66fc99e Initial load duke parents: diff changeset	176 "shouldn't be allocating with pending exception");
a61af66fc99e Initial load duke parents: diff changeset	177 if (StrictSafepointChecks) {
a61af66fc99e Initial load duke parents: diff changeset	178 assert(thread->allow_allocation(),
a61af66fc99e Initial load duke parents: diff changeset	179 "Allocation done by thread for which allocation is blocked "
a61af66fc99e Initial load duke parents: diff changeset	180 "by No_Allocation_Verifier!");
a61af66fc99e Initial load duke parents: diff changeset	181 // Allocation of an oop can always invoke a safepoint,
a61af66fc99e Initial load duke parents: diff changeset	182 // hence, the true argument
a61af66fc99e Initial load duke parents: diff changeset	183 thread->check_for_valid_safepoint_state(true);
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185 }
a61af66fc99e Initial load duke parents: diff changeset	186 #endif
a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 HeapWord* CollectedHeap::allocate_from_tlab_slow(Thread* thread, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // Retain tlab and allocate object in shared space if
a61af66fc99e Initial load duke parents: diff changeset	191 // the amount free in the tlab is too large to discard.
a61af66fc99e Initial load duke parents: diff changeset	192 if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
a61af66fc99e Initial load duke parents: diff changeset	193 thread->tlab().record_slow_allocation(size);
a61af66fc99e Initial load duke parents: diff changeset	194 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 // Discard tlab and allocate a new one.
a61af66fc99e Initial load duke parents: diff changeset	198 // To minimize fragmentation, the last TLAB may be smaller than the rest.
a61af66fc99e Initial load duke parents: diff changeset	199 size_t new_tlab_size = thread->tlab().compute_size(size);
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 thread->tlab().clear_before_allocation();
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 if (new_tlab_size == 0) {
a61af66fc99e Initial load duke parents: diff changeset	204 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 // Allocate a new TLAB...
a61af66fc99e Initial load duke parents: diff changeset	208 HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	209 if (obj == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	210 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212 if (ZeroTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	213 // ..and clear it.
a61af66fc99e Initial load duke parents: diff changeset	214 Copy::zero_to_words(obj, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	215 } else {
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	216 // ...and zap just allocated object.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	217 #ifdef ASSERT
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	218 // Skip mangling the space corresponding to the object header to
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	219 // ensure that the returned space is not considered parsable by
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	220 // any concurrent GC thread.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	221 size_t hdr_size = oopDesc::header_size();
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	222 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	223 #endif // ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	224 }
a61af66fc99e Initial load duke parents: diff changeset	225 thread->tlab().fill(obj, obj + size, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	226 return obj;
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	288 // invariants turns out, serendepitously, to be the same for both
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	289 // G1 and CMS.
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	290 //
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	291 // For any future collector, this code should be reexamined with
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	292 // that specific collector in mind, and the documentation above suitably
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	293 // extended and updated.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	302 MemRegion mr((HeapWord*)new_obj, new_obj->size());
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	303 assert(!mr.is_empty(), "Error");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	304 if (_defer_initial_card_mark) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	305 // Defer the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	306 thread->set_deferred_card_mark(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	307 } else {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	308 // Do the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	309 BarrierSet* bs = barrier_set();
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	310 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	311 bs->write_region(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	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: HeapWordParallelScavengeHeap::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 a61af66fc99e Initial load duke parents: diff changeset	401 HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	402 guarantee(false, "thread-local allocation buffers not supported");
a61af66fc99e Initial load duke parents: diff changeset	403 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 void CollectedHeap::ensure_parsability(bool retire_tlabs) {
a61af66fc99e Initial load duke parents: diff changeset	407 // The second disjunct in the assertion below makes a concession
a61af66fc99e Initial load duke parents: diff changeset	408 // for the start-up verification done while the VM is being
a61af66fc99e Initial load duke parents: diff changeset	409 // created. Callers be careful that you know that mutators
a61af66fc99e Initial load duke parents: diff changeset	410 // aren't going to interfere -- for instance, this is permissible
a61af66fc99e Initial load duke parents: diff changeset	411 // if we are still single-threaded and have either not yet
a61af66fc99e Initial load duke parents: diff changeset	412 // started allocating (nothing much to verify) or we have
a61af66fc99e Initial load duke parents: diff changeset	413 // started allocating but are now a full-fledged JavaThread
a61af66fc99e Initial load duke parents: diff changeset	414 // (and have thus made our TLAB's) available for filling.
a61af66fc99e Initial load duke parents: diff changeset	415 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	416 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	417 "Should only be called at a safepoint or at start-up"
a61af66fc99e Initial load duke parents: diff changeset	418 " otherwise concurrent mutator activity may make heap "
a61af66fc99e Initial load duke parents: diff changeset	419 " unparsable again");
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	420 const bool use_tlab = UseTLAB;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	421 const bool deferred = _defer_initial_card_mark;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	422 // 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	423 // 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	424 assert(!use_tlab \|\| Threads::first() != NULL,
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	425 "Attempt to fill tlabs before main thread has been added"
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	426 " to threads list is doomed to failure!");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	427 for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	428 if (use_tlab) thread->tlab().make_parsable(retire_tlabs);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	429 #ifdef COMPILER2
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	430 // 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	431 // card-table (or other remembered set structure) before GC starts
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	432 // processing the card-table (or other remembered set).
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	433 if (deferred) flush_deferred_store_barrier(thread);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	434 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	435 assert(!deferred, "Should be false");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	436 assert(thread->deferred_card_mark().is_empty(), "Should be empty");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	437 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	438 }
a61af66fc99e Initial load duke parents: diff changeset	439 }
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 void CollectedHeap::accumulate_statistics_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	442 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	443 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	444 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	445 "should only accumulate statistics on tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	446
a61af66fc99e Initial load duke parents: diff changeset	447 ThreadLocalAllocBuffer::accumulate_statistics_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	448 }
a61af66fc99e Initial load duke parents: diff changeset	449 }
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 void CollectedHeap::resize_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	452 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	453 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	454 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	455 "should only resize tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 ThreadLocalAllocBuffer::resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	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 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	486
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	487 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	488 debug_only(check_for_valid_allocation_state());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	489 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	490 assert(size >= 0, "int won't convert to size_t");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	491 HeapWord* obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	492 assert(ScavengeRootsInCode > 0, "must be");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	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 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	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 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	497 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	498 oop mirror = (oop)obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	499
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	500 java_lang_Class::set_oop_size(mirror, size);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	501
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	502 // Setup indirections
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	503 if (!real_klass.is_null()) {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	504 java_lang_Class::set_klass(mirror, real_klass());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	505 real_klass->set_java_mirror(mirror);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	506 }
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	507
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	508 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	509 assert(size == mk->instance_size(real_klass), "should have been set");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	510
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	511 // notify jvmti and dtrace
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	512 post_allocation_notify(klass, (oop)obj);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	513
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	514 return mirror;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	515 }
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	516
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	517 /////////////// Unit tests ///////////////
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	518
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	519 #ifndef PRODUCT
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	520 void CollectedHeap::test_is_in() {
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	521 CollectedHeap* heap = Universe::heap();
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	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 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	527 // Test that NULL is not in the heap.
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	528 assert(!heap->is_in(NULL), "NULL is unexpectedly in the heap");
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	529
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	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 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	533 assert(!heap->is_in(before_heap),
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	534 err_msg("before_heap: " PTR_FORMAT " is unexpectedly in the heap", before_heap));
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	535
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	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 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	539 assert(!heap->is_in(after_heap),
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	540 err_msg("after_heap: " PTR_FORMAT " is unexpectedly in the heap", after_heap));
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	541 }
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	542 #endif

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_interface/collectedHeap.cpp @ 8804:91bf0bdae37b